1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
 
 
2
 
2
 
 
 
 
 
 
 
1
2
 
 
 
 
 
2
 
 
2
 
 
2
2
 
1
 
 
 
2
 
 
1
1
1
 
1
1
 
 
1
1
 
1
 
 
1
 
2
 
 
 
 
 
1
 
1
 
1
 
 
 
 
1
2
2
3
3
3
3
1
 
 
3
3
 
 
 
 
3
 
 
 
1
3
1
 
 
 
1
1
 
 
 
 
 
 
 
1
 
1
1
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
1
 
 
6
6
 
1
 
2
 
1
 
2
 
 
 
 
1
1
 
1
 
 
 
 
1
 
 
 
 
 
 
1
 
 
1
1
 
 
1
1
 
1
1
1
1
1
1
1
 
1
1
 
1
 
 
 
 
/*
example.js
 
quickstart example
 
instruction
    1. save this script as example.js
    2. run the shell command:
        $ npm install npmtest-yarn && PORT=8081 node example.js
    3. play with the browser-demo on http://127.0.0.1:8081
*/
 
 
 
/* istanbul instrument in package npmtest_yarn */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - init-before
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || (local.modeJs === 'browser'
            ? local.global.utility2_npmtest_yarn
            : global.utility2_moduleExports);
        // export local
        local.global.local = local;
    }());
    switch (local.modeJs) {
 
 
 
    // init-after
    // run browser js-env code - init-after
    /* istanbul ignore next */
    case 'browser':
        local.testRunBrowser = function (event) {
            Eif (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('onreset'))) {
                // reset output
                Array.from(
                    document.querySelectorAll('body > .resettable')
                ).forEach(function (element) {
                    switch (element.tagName) {
                    case 'INPUT':
                    case 'TEXTAREA':
                        element.value = '';
                        break;
                    default:
                        element.textContent = '';
                    }
                });
            }
            switch (event && event.currentTarget && event.currentTarget.id) {
            case 'testRunButton1':
                // show tests
                Eif (document.querySelector('#testReportDiv1').style.display === 'none') {
                    document.querySelector('#testReportDiv1').style.display = 'block';
                    document.querySelector('#testRunButton1').textContent =
                        'hide internal test';
                    local.modeTest = true;
                    local.testRunDefault(local);
                // hide tests
                } else {
                    document.querySelector('#testReportDiv1').style.display = 'none';
                    document.querySelector('#testRunButton1').textContent = 'run internal test';
                }
                break;
            // custom-case
            default:
                break;
            }
            Iif (document.querySelector('#inputTextareaEval1') && (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('oneval')))) {
                // try to eval input-code
                try {
                    /*jslint evil: true*/
                    eval(document.querySelector('#inputTextareaEval1').value);
                } catch (errorCaught) {
                    console.error(errorCaught);
                }
            }
        };
        // log stderr and stdout to #outputTextareaStdout1
        ['error', 'log'].forEach(function (key) {
            console[key + '_original'] = console[key];
            console[key] = function () {
                var element;
                console[key + '_original'].apply(console, arguments);
                element = document.querySelector('#outputTextareaStdout1');
                Iif (!element) {
                    return;
                }
                // append text to #outputTextareaStdout1
                element.value += Array.from(arguments).map(function (arg) {
                    return typeof arg === 'string'
                        ? arg
                        : JSON.stringify(arg, null, 4);
                }).join(' ') + '\n';
                // scroll textarea to bottom
                element.scrollTop = element.scrollHeight;
            };
        });
        // init event-handling
        ['change', 'click', 'keyup'].forEach(function (event) {
            Array.from(document.querySelectorAll('.on' + event)).forEach(function (element) {
                element.addEventListener(event, local.testRunBrowser);
            });
        });
        // run tests
        local.testRunBrowser();
        break;
 
 
 
    // run node js-env code - init-after
    /* istanbul ignore next */
    case 'node':
        // export local
        module.exports = local;
        // require modules
        local.fs = require('fs');
        local.http = require('http');
        local.url = require('url');
        // init assets
        local.assetsDict = local.assetsDict || {};
        /* jslint-ignore-begin */
        local.assetsDict['/assets.index.template.html'] = '\
<!doctype html>\n\
<html lang="en">\n\
<head>\n\
<meta charset="UTF-8">\n\
<meta name="viewport" content="width=device-width, initial-scale=1">\n\
<title>{{env.npm_package_name}} (v{{env.npm_package_version}})</title>\n\
<style>\n\
/*csslint\n\
    box-sizing: false,\n\
    universal-selector: false\n\
*/\n\
* {\n\
    box-sizing: border-box;\n\
}\n\
body {\n\
    background: #dde;\n\
    font-family: Arial, Helvetica, sans-serif;\n\
    margin: 2rem;\n\
}\n\
body > * {\n\
    margin-bottom: 1rem;\n\
}\n\
.utility2FooterDiv {\n\
    margin-top: 20px;\n\
    text-align: center;\n\
}\n\
</style>\n\
<style>\n\
/*csslint\n\
*/\n\
textarea {\n\
    font-family: monospace;\n\
    height: 10rem;\n\
    width: 100%;\n\
}\n\
textarea[readonly] {\n\
    background: #ddd;\n\
}\n\
</style>\n\
</head>\n\
<body>\n\
<!-- utility2-comment\n\
<div id="ajaxProgressDiv1" style="background: #d00; height: 2px; left: 0; margin: 0; padding: 0; position: fixed; top: 0; transition: background 0.5s, width 1.5s; width: 25%;"></div>\n\
utility2-comment -->\n\
<h1>\n\
<!-- utility2-comment\n\
    <a\n\
        {{#if env.npm_package_homepage}}\n\
        href="{{env.npm_package_homepage}}"\n\
        {{/if env.npm_package_homepage}}\n\
        target="_blank"\n\
    >\n\
utility2-comment -->\n\
        {{env.npm_package_name}} (v{{env.npm_package_version}})\n\
<!-- utility2-comment\n\
    </a>\n\
utility2-comment -->\n\
</h1>\n\
<h3>{{env.npm_package_description}}</h3>\n\
<!-- utility2-comment\n\
<h4><a download href="assets.app.js">download standalone app</a></h4>\n\
<button class="onclick onreset" id="testRunButton1">run internal test</button><br>\n\
<div id="testReportDiv1" style="display: none;"></div>\n\
utility2-comment -->\n\
\n\
\n\
\n\
<label>stderr and stdout</label>\n\
<textarea class="resettable" id="outputTextareaStdout1" readonly></textarea>\n\
<!-- utility2-comment\n\
{{#if isRollup}}\n\
<script src="assets.app.js"></script>\n\
{{#unless isRollup}}\n\
utility2-comment -->\n\
<script src="assets.utility2.rollup.js"></script>\n\
<script src="jsonp.utility2._stateInit?callback=window.utility2._stateInit"></script>\n\
<script src="assets.npmtest_yarn.rollup.js"></script>\n\
<script src="assets.example.js"></script>\n\
<script src="assets.test.js"></script>\n\
<!-- utility2-comment\n\
{{/if isRollup}}\n\
utility2-comment -->\n\
<div class="utility2FooterDiv">\n\
    [ this app was created with\n\
    <a href="https://github.com/kaizhu256/node-utility2" target="_blank">utility2</a>\n\
    ]\n\
</div>\n\
</body>\n\
</html>\n\
';
        /* jslint-ignore-end */
        Iif (local.templateRender) {
            local.assetsDict['/'] = local.templateRender(
                local.assetsDict['/assets.index.template.html'],
                {
                    env: local.objectSetDefault(local.env, {
                        npm_package_description: 'the greatest app in the world!',
                        npm_package_name: 'my-app',
                        npm_package_nameAlias: 'my_app',
                        npm_package_version: '0.0.1'
                    })
                }
            );
        } else {
            local.assetsDict['/'] = local.assetsDict['/assets.index.template.html']
                .replace((/\{\{env\.(\w+?)\}\}/g), function (match0, match1) {
                    // jslint-hack
                    String(match0);
                    switch (match1) {
                    case 'npm_package_description':
                        return 'the greatest app in the world!';
                    case 'npm_package_name':
                        return 'my-app';
                    case 'npm_package_nameAlias':
                        return 'my_app';
                    case 'npm_package_version':
                        return '0.0.1';
                    }
                });
        }
        // run the cli
        Eif (local.global.utility2_rollup || module !== require.main) {
            break;
        }
        local.assetsDict['/assets.example.js'] =
            local.assetsDict['/assets.example.js'] ||
            local.fs.readFileSync(__filename, 'utf8');
        // bug-workaround - long $npm_package_buildCustomOrg
        /* jslint-ignore-begin */
        local.assetsDict['/assets.npmtest_yarn.rollup.js'] =
            local.assetsDict['/assets.npmtest_yarn.rollup.js'] ||
            local.fs.readFileSync(
                local.npmtest_yarn.__dirname + '/lib.npmtest_yarn.js',
                'utf8'
            ).replace((/^#!/), '//');
        /* jslint-ignore-end */
        local.assetsDict['/favicon.ico'] = local.assetsDict['/favicon.ico'] || '';
        // if $npm_config_timeout_exit exists,
        // then exit this process after $npm_config_timeout_exit ms
        if (Number(process.env.npm_config_timeout_exit)) {
            setTimeout(process.exit, Number(process.env.npm_config_timeout_exit));
        }
        // start server
        if (local.global.utility2_serverHttp1) {
            break;
        }
        process.env.PORT = process.env.PORT || '8081';
        console.error('server starting on port ' + process.env.PORT);
        local.http.createServer(function (request, response) {
            request.urlParsed = local.url.parse(request.url);
            if (local.assetsDict[request.urlParsed.pathname] !== undefined) {
                response.end(local.assetsDict[request.urlParsed.pathname]);
                return;
            }
            response.statusCode = 404;
            response.end();
        }).listen(process.env.PORT);
        break;
    }
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
2
 
2
1
 
1
1
1
 
 
 
 
 
/* istanbul instrument in package npmtest_yarn */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - init-before
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || local;
        // init lib
        local.local = local.npmtest_yarn = local;
        // init exports
        if (local.modeJs === 'browser') {
            local.global.utility2_npmtest_yarn = local;
        } else {
            module.exports = local;
            module.exports.__dirname = __dirname;
            module.exports.module = module;
        }
    }());
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
2
 
 
1
 
 
 
1
 
 
1
 
1
 
 
2
 
 
 
 
 
2
2
 
2
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
2
2
 
2
 
 
 
 
 
1
 
 
 
 
 
 
1
 
 
 
1
 
 
1
 
 
 
 
 
 
1
 
 
 
 
 
 
1
1
 
 
1
 
 
 
 
 
 
1
1
1
1
1
1
 
 
1
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
1
1
 
 
 
1
1
 
 
 
 
/* istanbul instrument in package npmtest_yarn */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - init-before
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        switch (local.modeJs) {
        // re-init local from window.local
        case 'browser':
            local = local.global.utility2.objectSetDefault(
                local.global.utility2_rollup || local.global.local,
                local.global.utility2
            );
            break;
        // re-init local from example.js
        case 'node':
            local = (local.global.utility2_rollup || require('utility2'))
                .requireReadme();
            break;
        }
        // export local
        local.global.local = local;
    }());
 
 
 
    // run shared js-env code - function
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - function
    case 'browser':
        break;
 
 
 
    // run node js-env code - function
    case 'node':
        break;
    }
 
 
 
    // run shared js-env code - init-after
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - init-after
    case 'browser':
        local.testCase_browser_nullCase = local.testCase_browser_nullCase || function (
            options,
            onError
        ) {
        /*
         * this function will test browsers's null-case handling-behavior-behavior
         */
            onError(null, options);
        };
 
        // run tests
        local.nop(local.modeTest &&
            document.querySelector('#testRunButton1') &&
            document.querySelector('#testRunButton1').click());
        break;
 
 
 
    // run node js-env code - init-after
    /* istanbul ignore next */
    case 'node':
        local.testCase_buildApidoc_default = local.testCase_buildApidoc_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApidoc's default handling-behavior-behavior
         */
            options = { modulePathList: module.paths };
            local.buildApidoc(options, onError);
        };
 
        local.testCase_buildApp_default = local.testCase_buildApp_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApp's default handling-behavior-behavior
         */
            local.testCase_buildReadme_default(options, local.onErrorThrow);
            local.testCase_buildLib_default(options, local.onErrorThrow);
            local.testCase_buildTest_default(options, local.onErrorThrow);
            local.testCase_buildCustomOrg_default(options, local.onErrorThrow);
            options = [];
            local.buildApp(options, onError);
        };
 
        local.testCase_buildCustomOrg_default = local.testCase_buildCustomOrg_default ||
            function (options, onError) {
            /*
             * this function will test buildCustomOrg's default handling-behavior
             */
                options = {};
                local.buildCustomOrg(options, onError);
            };
 
        local.testCase_buildLib_default = local.testCase_buildLib_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildLib's default handling-behavior
         */
            options = {};
            local.buildLib(options, onError);
        };
 
        local.testCase_buildReadme_default = local.testCase_buildReadme_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildReadme's default handling-behavior-behavior
         */
            options = {};
            local.buildReadme(options, onError);
        };
 
        local.testCase_buildTest_default = local.testCase_buildTest_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildTest's default handling-behavior
         */
            options = {};
            local.buildTest(options, onError);
        };
 
        local.testCase_webpage_default = local.testCase_webpage_default || function (
            options,
            onError
        ) {
        /*
         * this function will test webpage's default handling-behavior
         */
            options = { modeCoverageMerge: true, url: local.serverLocalHost + '?modeTest=1' };
            local.browserTest(options, onError);
        };
 
        // run test-server
        local.testRunServer(local);
        break;
    }
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
 
 
 
 
 
 
1
1
1
 
1
 
1
1
 
 
 
 
 
 
 
 
1
1
 
 
 
1
1
1
 
 
1
1
 
 
1
1
1
 
 
 
 
1
 
 
1
 
1
 
 
//#!/usr/bin/env node
 
/* eslint-disable no-var */
/* eslint-disable flowtype/require-valid-file-annotation */
'use strict';
 
// validate that used node version is supported
var semver = require('semver');
var ver = process.versions.node;
ver = ver.split('-')[0]; // explode and truncate tag from version #511
 
var path = null;
 
Eif (semver.satisfies(ver, '>=5.0.0')) {
  path = '../lib/cli/index.js';
} else if (semver.satisfies(ver, '>=4.0.0')) {
  path = '../lib-legacy/cli/index.js';
} else {
  console.log(require('chalk').red('Node version ' + ver + ' is not supported, please use Node.js 4.0 or higher.'));
  process.exit(1);
}
 
// load v8-compile-cache
Eif (semver.satisfies(ver, '>=5.7.0')) {
  require('v8-compile-cache');
}
 
// ensure cache directory exists
var mkdirp = require('mkdirp');
var constants = require('../lib-legacy/constants');
mkdirp.sync(constants.MODULE_CACHE_DIRECTORY);
 
// init roadrunner
var YARN_VERSION = require('../package.json').version;
var roadrunner = require('roadrunner');
 
// load cache
roadrunner.load(constants.CACHE_FILENAME);
var cacheVersion = roadrunner.get('CACHE_BREAKER').version;
Iif (!cacheVersion || cacheVersion !== YARN_VERSION) {
  // reset cache if it's for an older yarn
  roadrunner.reset(constants.CACHE_FILENAME);
}
// set this cache to the current yarn version
roadrunner.set('CACHE_BREAKER', {version: YARN_VERSION});
 
// save cache on SIGINT
roadrunner.setup(constants.CACHE_FILENAME);
 
module.exports = require(path);
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
 
1
 
 
1
1
1
1
 
1
 
1
 
1
1
1
 
1
1
1
 
 
1
 
 
1
 
 
1
 
 
1
 
1
 
1
 
2
 
 
 
 
2
 
 
1
1
 
 
 
1
 
 
1
1
1
1
1
 
1
1
1
1
1
 
1
1
1
 
1
 
1
1
 
 
1
 
 
 
 
 
 
 
 
 
1
 
 
1
1
1
 
 
 
 
1
 
1
1
 
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getPathKey = getPathKey;
exports.isRootUser = isRootUser;
const path = require('path');
const userHome = require('./util/user-home-dir').default;
 
const DEPENDENCY_TYPES = exports.DEPENDENCY_TYPES = ['devDependencies', 'dependencies', 'optionalDependencies', 'peerDependencies'];
 
const YARN_REGISTRY = exports.YARN_REGISTRY = 'https://registry.yarnpkg.com';
 
const YARN_DOCS = exports.YARN_DOCS = 'https://yarnpkg.com/en/docs/cli/';
const YARN_INSTALLER_SH = exports.YARN_INSTALLER_SH = 'https://yarnpkg.com/install.sh';
const YARN_INSTALLER_MSI = exports.YARN_INSTALLER_MSI = 'https://yarnpkg.com/latest.msi';
 
const SELF_UPDATE_VERSION_URL = exports.SELF_UPDATE_VERSION_URL = 'https://yarnpkg.com/latest-version';
const SELF_UPDATE_TARBALL_URL = exports.SELF_UPDATE_TARBALL_URL = 'https://yarnpkg.com/latest.tar.gz';
const SELF_UPDATE_DOWNLOAD_FOLDER = exports.SELF_UPDATE_DOWNLOAD_FOLDER = 'updates';
 
// cache version, bump whenever we make backwards incompatible changes
const CACHE_VERSION = exports.CACHE_VERSION = 1;
 
// lockfile version, bump whenever we make backwards incompatible changes
const LOCKFILE_VERSION = exports.LOCKFILE_VERSION = 1;
 
// max amount of network requests to perform concurrently
const NETWORK_CONCURRENCY = exports.NETWORK_CONCURRENCY = 8;
 
// max amount of child processes to execute concurrently
const CHILD_CONCURRENCY = exports.CHILD_CONCURRENCY = 5;
 
const REQUIRED_PACKAGE_KEYS = exports.REQUIRED_PACKAGE_KEYS = ['name', 'version', '_uid'];
 
function getDirectory(category) {
  // use %LOCALAPPDATA%/Yarn on Windows
  Iif (process.platform === 'win32' && process.env.LOCALAPPDATA) {
    return path.join(process.env.LOCALAPPDATA, 'Yarn', category);
  }
 
  // otherwise use ~/.{category}/yarn
  return path.join(userHome, `.${category}`, 'yarn');
}
 
function getCacheDirectory() {
  Iif (process.platform === 'darwin') {
    return path.join(userHome, 'Library', 'Caches', 'Yarn');
  }
 
  return getDirectory('cache');
}
 
const MODULE_CACHE_DIRECTORY = exports.MODULE_CACHE_DIRECTORY = getCacheDirectory();
const CONFIG_DIRECTORY = exports.CONFIG_DIRECTORY = getDirectory('config');
const LINK_REGISTRY_DIRECTORY = exports.LINK_REGISTRY_DIRECTORY = path.join(CONFIG_DIRECTORY, 'link');
const GLOBAL_MODULE_DIRECTORY = exports.GLOBAL_MODULE_DIRECTORY = path.join(CONFIG_DIRECTORY, 'global');
const CACHE_FILENAME = exports.CACHE_FILENAME = path.join(MODULE_CACHE_DIRECTORY, '.roadrunner.json');
 
const INTEGRITY_FILENAME = exports.INTEGRITY_FILENAME = '.yarn-integrity';
const LOCKFILE_FILENAME = exports.LOCKFILE_FILENAME = 'yarn.lock';
const METADATA_FILENAME = exports.METADATA_FILENAME = '.yarn-metadata.json';
const TARBALL_FILENAME = exports.TARBALL_FILENAME = '.yarn-tarball.tgz';
const CLEAN_FILENAME = exports.CLEAN_FILENAME = '.yarnclean';
 
const DEFAULT_INDENT = exports.DEFAULT_INDENT = '  ';
const SINGLE_INSTANCE_PORT = exports.SINGLE_INSTANCE_PORT = 31997;
const SINGLE_INSTANCE_FILENAME = exports.SINGLE_INSTANCE_FILENAME = '.yarn-single-instance';
 
const ENV_PATH_KEY = exports.ENV_PATH_KEY = getPathKey(process.platform, process.env);
 
function getPathKey(platform, env) {
  let pathKey = 'PATH';
 
  // windows calls its path "Path" usually, but this is not guaranteed.
  Iif (platform === 'win32') {
    pathKey = 'Path';
 
    for (const key in env) {
      if (key.toLowerCase() === 'path') {
        pathKey = key;
      }
    }
  }
 
  return pathKey;
}
 
function getUid() {
  Eif (process.platform !== 'win32' && process.getuid) {
    return process.getuid();
  }
  return null;
}
 
const ROOT_USER = exports.ROOT_USER = isRootUser(getUid());
 
function isRootUser(uid) {
  return uid === 0;
}
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 
 
1
 
 
 
1
 
1
 
 
 
1
 
1
1
 
 
1
 
1
 
1
 
 
 
1
 
1
1
 
 
1
 
1
 
 
 
2
 
1
 
1
 
1
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
1
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _promise;
 
function _load_promise() {
  return _promise = _interopRequireDefault(require('babel-runtime/core-js/promise'));
}
 
var _assign;
 
function _load_assign() {
  return _assign = _interopRequireDefault(require('babel-runtime/core-js/object/assign'));
}
 
exports.testEngine = testEngine;
 
var _errors;
 
function _load_errors() {
  return _errors = require('./errors.js');
}
 
var _map;
 
function _load_map() {
  return _map = _interopRequireDefault(require('./util/map.js'));
}
 
var _misc;
 
function _load_misc() {
  return _misc = require('./util/misc.js');
}
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
const invariant = require('invariant');
 
const semver = require('semver');
 
const VERSIONS = (0, (_assign || _load_assign()).default)({}, process.versions, {
  yarn: require('../package.json').version
});
 
function isValid(items, actual) {
  let isNotWhitelist = true;
  let isBlacklist = false;
 
  for (const item of items) {
    // blacklist
    if (item[0] === '!') {
      isBlacklist = true;
 
      if (actual === item.slice(1)) {
        return false;
      }
      // whitelist
    } else {
      isNotWhitelist = false;
 
      if (item === actual) {
        return true;
      }
    }
  }
 
  // npm allows blacklists and whitelists to be mixed. Blacklists with
  // whitelisted items should be treated as whitelists.
  return isBlacklist && isNotWhitelist;
}
 
const aliases = (0, (_map || _load_map()).default)({
  iojs: 'node' });
 
const ignore = ['npm', // we'll never satisfy this for obvious reasons
'teleport', // a module bundler used by some modules
'rhino'];
 
function testEngine(name, range, versions, looseSemver) {
  const actual = versions[name];
  if (!actual) {
    return false;
  }
 
  if (!semver.valid(actual, looseSemver)) {
    return false;
  }
 
  if (semver.satisfies(actual, range, looseSemver)) {
    return true;
  }
 
  if (name === 'node' && semver.gt(actual, '1.0.0', looseSemver)) {
    // WARNING: this is a massive hack and is super gross but necessary for compatibility
    // some modules have the `engines.node` field set to a caret version below semver major v1
    // eg. ^0.12.0. this is problematic as we enforce engines checks and node is now on version >=1
    // to allow this pattern we transform the node version to fake ones in the minor range 10-13
    const major = semver.major(actual, looseSemver);
    const fakes = [`0.10.${major}`, `0.11.${major}`, `0.12.${major}`, `0.13.${major}`];
    for (const actualFake of fakes) {
      if (semver.satisfies(actualFake, range, looseSemver)) {
        return true;
      }
    }
  }
 
  // incompatible version
  return false;
}
 
class PackageCompatibility {
  constructor(config, resolver, ignoreEngines) {
    this.reporter = config.reporter;
    this.resolver = resolver;
    this.config = config;
    this.ignoreEngines = ignoreEngines;
  }
 
  static isValidArch(archs) {
    return isValid(archs, process.arch);
  }
 
  static isValidPlatform(platforms) {
    return isValid(platforms, process.platform);
  }
 
  check(info) {
    let didIgnore = false;
    let didError = false;
    const reporter = this.reporter;
    const human = `${info.name}@${info.version}`;
 
    const pushError = msg => {
      const ref = info._reference;
      invariant(ref, 'expected package reference');
 
      if (ref.optional) {
        ref.ignore = true;
 
        reporter.warn(`${human}: ${msg}`);
        if (!didIgnore) {
          reporter.info(reporter.lang('optionalCompatibilityExcluded', human));
          didIgnore = true;
        }
      } else {
        reporter.error(`${human}: ${msg}`);
        didError = true;
      }
    };
 
    const invalidPlatform = !this.config.ignorePlatform && Array.isArray(info.os) && info.os.length > 0 && !PackageCompatibility.isValidPlatform(info.os);
    if (invalidPlatform) {
      pushError(this.reporter.lang('incompatibleOS', process.platform));
    }
 
    const invalidCpu = !this.config.ignorePlatform && Array.isArray(info.cpu) && info.cpu.length > 0 && !PackageCompatibility.isValidArch(info.cpu);
    if (invalidCpu) {
      pushError(this.reporter.lang('incompatibleCPU', process.arch));
    }
 
    if (!this.ignoreEngines && typeof info.engines === 'object') {
      for (const entry of (0, (_misc || _load_misc()).entries)(info.engines)) {
        let name = entry[0];
        const range = entry[1];
 
        if (aliases[name]) {
          name = aliases[name];
        }
 
        if (VERSIONS[name]) {
          if (!testEngine(name, range, VERSIONS, this.config.looseSemver)) {
            pushError(this.reporter.lang('incompatibleEngine', name, range));
          }
        } else if (ignore.indexOf(name) < 0) {
          this.reporter.warn(`${human}: ${this.reporter.lang('invalidEngine', name)}`);
        }
      }
    }
 
    if (didError) {
      throw new (_errors || _load_errors()).MessageError(reporter.lang('foundIncompatible'));
    }
  }
 
  init() {
    const infos = this.resolver.getManifests();
    for (const info of infos) {
      this.check(info);
    }
    return (_promise || _load_promise()).default.resolve();
  }
}
exports.default = PackageCompatibility;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _promise;
 
function _load_promise() {
  return _promise = _interopRequireDefault(require('babel-runtime/core-js/promise'));
}
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
const semver = require('semver');
 
// This isn't really a "proper" constraint resolver. We just return the highest semver
// version in the versions passed that satisfies the input range. This vastly reduces
// the complexity and is very efficient for package resolution.
 
class PackageConstraintResolver {
  constructor(config, reporter) {
    this.reporter = reporter;
    this.config = config;
  }
 
  reduce(versions, range) {
    if (range === 'latest') {
      // Usually versions are already ordered and the last one is the latest
      return (_promise || _load_promise()).default.resolve(versions[versions.length - 1]);
    } else {
      return (_promise || _load_promise()).default.resolve(semver.maxSatisfying(versions, range, this.config.looseSemver));
    }
  }
}
exports.default = PackageConstraintResolver;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _asyncToGenerator2;
 
function _load_asyncToGenerator() {
  return _asyncToGenerator2 = _interopRequireDefault(require('babel-runtime/helpers/asyncToGenerator'));
}
 
var _errors;
 
function _load_errors() {
  return _errors = require('./errors.js');
}
 
var _index;
 
function _load_index() {
  return _index = _interopRequireWildcard(require('./fetchers/index.js'));
}
 
var _fs;
 
function _load_fs() {
  return _fs = _interopRequireWildcard(require('./util/fs.js'));
}
 
var _promise;
 
function _load_promise() {
  return _promise = _interopRequireWildcard(require('./util/promise.js'));
}
 
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
class PackageFetcher {
  constructor(config, resolver) {
    this.reporter = config.reporter;
    this.resolver = resolver;
    this.config = config;
  }
 
  fetchCache(dest, fetcher) {
    var _this = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      var _ref = yield _this.config.readPackageMetadata(dest);
 
      const hash = _ref.hash,
            pkg = _ref.package;
 
      return {
        package: pkg,
        resolved: yield fetcher.getResolvedFromCached(hash),
        hash: hash,
        dest: dest,
        cached: true
      };
    })();
  }
 
  fetch(ref) {
    var _this2 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      const dest = _this2.config.generateHardModulePath(ref);
 
      const remote = ref.remote;
      const Fetcher = (_index || _load_index())[remote.type];
      if (!Fetcher) {
        throw new (_errors || _load_errors()).MessageError(_this2.reporter.lang('unknownFetcherFor', remote.type));
      }
 
      const fetcher = new Fetcher(dest, remote, _this2.config);
 
      if (yield _this2.config.isValidModuleDest(dest)) {
        return _this2.fetchCache(dest, fetcher);
      }
 
      // remove as the module may be invalid
      yield (_fs || _load_fs()).unlink(dest);
 
      try {
        return yield fetcher.fetch();
      } catch (err) {
        try {
          yield (_fs || _load_fs()).unlink(dest);
        } catch (err2) {
          // what do?
        }
        throw err;
      }
    })();
  }
 
  maybeFetch(ref) {
    var _this3 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      try {
        return yield _this3.fetch(ref);
      } catch (err) {
        if (ref.optional) {
          _this3.reporter.error(err.message);
          return null;
        } else {
          throw err;
        }
      }
    })();
  }
 
  init() {
    var _this4 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      const pkgs = _this4.resolver.getPackageReferences();
      const tick = _this4.reporter.progress(pkgs.length);
 
      yield (_promise || _load_promise()).queue(pkgs, (() => {
        var _ref2 = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* (ref) {
          const res = yield _this4.maybeFetch(ref);
          let newPkg;
 
          if (res) {
            newPkg = res.package;
 
            // update with new remote
            // but only if there was a hash previously as the tarball fetcher does not provide a hash.
            if (ref.remote.hash) {
              ref.remote.hash = res.hash;
            }
 
            if (res.resolved) {
              ref.remote.resolved = res.resolved;
            }
          }
 
          if (newPkg) {
            // update with fresh manifest
            yield _this4.resolver.updateManifest(ref, newPkg);
          }
 
          if (tick) {
            tick(ref.name);
          }
        });
 
        return function (_x) {
          return _ref2.apply(this, arguments);
        };
      })(), _this4.config.networkConcurrency);
    })();
  }
}
exports.default = PackageFetcher;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
 
 
1
 
 
1
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.HoistManifest = undefined;
 
var _keys;
 
function _load_keys() {
  return _keys = _interopRequireDefault(require('babel-runtime/core-js/object/keys'));
}
 
var _set;
 
function _load_set() {
  return _set = _interopRequireDefault(require('babel-runtime/core-js/set'));
}
 
var _slicedToArray2;
 
function _load_slicedToArray() {
  return _slicedToArray2 = _interopRequireDefault(require('babel-runtime/helpers/slicedToArray'));
}
 
var _map;
 
function _load_map() {
  return _map = _interopRequireDefault(require('babel-runtime/core-js/map'));
}
 
var _misc;
 
function _load_misc() {
  return _misc = require('./util/misc.js');
}
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
const invariant = require('invariant');
const path = require('path');
 
let historyCounter = 0;
 
class HoistManifest {
  constructor(key, parts, pkg, loc, isIgnored, inheritIsIgnored) {
    this.isIgnored = isIgnored;
    this.inheritIsIgnored = inheritIsIgnored;
    this.loc = loc;
    this.pkg = pkg;
 
    this.key = key;
    this.parts = parts;
    this.originalKey = key;
    this.previousKeys = [];
 
    this.history = [];
    this.addHistory(`Start position = ${key}`);
  }
 
  addHistory(msg) {
    this.history.push(`${++historyCounter}: ${msg}`);
  }
}
 
exports.HoistManifest = HoistManifest;
class PackageHoister {
  constructor(config, resolver) {
    this.resolver = resolver;
    this.config = config;
 
    this.taintedKeys = new (_map || _load_map()).default();
    this.levelQueue = [];
    this.tree = new (_map || _load_map()).default();
  }
 
  /**
   * Taint this key and prevent any modules from being hoisted to it.
   */
 
  taintKey(key, info) {
    const existingTaint = this.taintedKeys.get(key);
    if (existingTaint && existingTaint.loc !== info.loc) {
      return false;
    } else {
      this.taintedKeys.set(key, info);
      return true;
    }
  }
 
  /**
   * Implode an array of ancestry parts into a key.
   */
 
  implodeKey(parts) {
    return parts.join('#');
  }
 
  /**
   * Seed the hoister with patterns taken from the included resolver.
   */
 
  seed(patterns) {
    this.prepass(patterns);
 
    for (const pattern of this.resolver.dedupePatterns(patterns)) {
      this._seed(pattern);
    }
 
    while (true) {
      let queue = this.levelQueue;
      if (!queue.length) {
        this._propagateNonIgnored();
        return;
      }
 
      this.levelQueue = [];
 
      // sort queue to get determinism between runs
      queue = queue.sort((_ref, _ref2) => {
        var _ref4 = (0, (_slicedToArray2 || _load_slicedToArray()).default)(_ref, 1);
 
        let aPattern = _ref4[0];
 
        var _ref3 = (0, (_slicedToArray2 || _load_slicedToArray()).default)(_ref2, 1);
 
        let bPattern = _ref3[0];
 
        return (0, (_misc || _load_misc()).sortAlpha)(aPattern, bPattern);
      });
 
      //
      const infos = [];
      for (const _ref5 of queue) {
        var _ref6 = (0, (_slicedToArray2 || _load_slicedToArray()).default)(_ref5, 2);
 
        const pattern = _ref6[0];
        const parents = _ref6[1];
 
        const info = this._seed(pattern, parents);
        if (info) {
          infos.push(info);
        }
      }
 
      //
      for (const info of infos) {
        this.hoist(info);
      }
    }
  }
 
  /**
   * Seed the hoister with a specific pattern.
   */
 
  _seed(pattern, parent) {
    //
    const pkg = this.resolver.getStrictResolvedPattern(pattern);
    const ref = pkg._reference;
    invariant(ref, 'expected reference');
 
    //
    let parentParts = [];
    let isIgnored = ref.ignore;
    let inheritIsIgnored = false;
 
    if (parent) {
      if (!this.tree.get(parent.key)) {
        return null;
      }
      // non ignored dependencies inherit parent's ignored status
      // parent may transition from ignored to non ignored when hoisted if it is used in another non ignored branch
      if (!isIgnored && parent.isIgnored) {
        isIgnored = parent.isIgnored;
        inheritIsIgnored = true;
      }
      parentParts = parent.parts;
    }
 
    //
    const loc = this.config.generateHardModulePath(ref);
    const parts = parentParts.concat(pkg.name);
    const key = this.implodeKey(parts);
    const info = new HoistManifest(key, parts, pkg, loc, isIgnored, inheritIsIgnored);
 
    //
    this.tree.set(key, info);
    this.taintKey(key, info);
 
    //
    for (const depPattern of ref.dependencies) {
      this.levelQueue.push([depPattern, info]);
    }
 
    return info;
  }
 
  /**
   * Propagate inherited ignore statuses from non-ignored to ignored packages
  */
 
  _propagateNonIgnored() {
    //
    const toVisit = [];
 
    // enumerate all non-ignored packages
    for (const entry of this.tree.entries()) {
      if (!entry[1].isIgnored) {
        toVisit.push(entry[1]);
      }
    }
 
    // visit them
    while (toVisit.length) {
      const info = toVisit.shift();
      const ref = info.pkg._reference;
      invariant(ref, 'expected reference');
 
      for (const depPattern of ref.dependencies) {
        const depinfo = this._lookupDependency(info, depPattern);
        if (depinfo && depinfo.isIgnored && depinfo.inheritIsIgnored) {
          depinfo.isIgnored = false;
          info.addHistory(`Mark as non-ignored because of usage by ${info.key}`);
          toVisit.push(depinfo);
        }
      }
    }
  }
 
  /**
   * Looks up the package a dependency resolves to
  */
 
  _lookupDependency(info, depPattern) {
    //
    const pkg = this.resolver.getStrictResolvedPattern(depPattern);
    const ref = pkg._reference;
    invariant(ref, 'expected reference');
 
    //
    for (let i = info.parts.length; i >= 0; i--) {
      const checkParts = info.parts.slice(0, i).concat(pkg.name);
      const checkKey = this.implodeKey(checkParts);
      const existing = this.tree.get(checkKey);
      if (existing) {
        return existing;
      }
    }
 
    return null;
  }
 
  /**
   * Find the highest position we can hoist this module to.
   */
 
  getNewParts(key, info, parts) {
    let stepUp = false;
 
    const fullKey = this.implodeKey(parts);
    const stack = []; // stack of removed parts
    const name = parts.pop();
 
    //
    for (let i = parts.length - 1; i >= 0; i--) {
      const checkParts = parts.slice(0, i).concat(name);
      const checkKey = this.implodeKey(checkParts);
      info.addHistory(`Looked at ${checkKey} for a match`);
 
      const existing = this.tree.get(checkKey);
      if (existing) {
        if (existing.loc === info.loc) {
          // switch to non ignored if earlier deduped version was ignored
          if (existing.isIgnored && !info.isIgnored) {
            existing.isIgnored = info.isIgnored;
          }
 
          existing.addHistory(`Deduped ${fullKey} to this item`);
          return { parts: checkParts, duplicate: true };
        } else {
          // everything above will be shadowed and this is a conflict
          info.addHistory(`Found a collision at ${checkKey}`);
          break;
        }
      }
 
      const existingTaint = this.taintedKeys.get(checkKey);
      if (existingTaint && existingTaint.loc !== info.loc) {
        info.addHistory(`Broken by ${checkKey}`);
        break;
      }
    }
 
    // remove redundant parts that wont collide
    while (parts.length) {
      const checkParts = parts.concat(name);
      const checkKey = this.implodeKey(checkParts);
 
      //
      const existing = this.tree.get(checkKey);
      if (existing) {
        stepUp = true;
        break;
      }
 
      // check if we're trying to hoist ourselves to a previously unflattened module key,
      // this will result in a conflict and we'll need to move ourselves up
      if (key !== checkKey && this.taintedKeys.has(checkKey)) {
        stepUp = true;
        break;
      }
 
      //
      stack.push(parts.pop());
    }
 
    //
    parts.push(name);
 
    //
    const isValidPosition = parts => {
      const key = this.implodeKey(parts);
      const existing = this.tree.get(key);
      if (existing && existing.loc === info.loc) {
        return true;
      }
 
      // ensure there's no taint or the taint is us
      const existingTaint = this.taintedKeys.get(key);
      if (existingTaint && existingTaint.loc !== info.loc) {
        return false;
      }
 
      return true;
    };
 
    // we need to special case when we attempt to hoist to the top level as the `existing` logic
    // wont be hit in the above `while` loop and we could conflict
    if (!isValidPosition(parts)) {
      stepUp = true;
    }
 
    // sometimes we need to step up to a parent module to install ourselves
    while (stepUp && stack.length) {
      info.addHistory(`Stepping up from ${this.implodeKey(parts)}`);
 
      parts.pop(); // remove `name`
      parts.push(stack.pop(), name);
 
      if (isValidPosition(parts)) {
        info.addHistory(`Found valid position ${this.implodeKey(parts)}`);
        stepUp = false;
      }
    }
 
    return { parts: parts, duplicate: false };
  }
 
  /**
   * Hoist all seeded patterns to their highest positions.
   */
 
  hoist(info) {
    const key = info.key,
          rawParts = info.parts;
 
    // remove this item from the `tree` map so we can ignore it
 
    this.tree.delete(key);
 
    var _getNewParts = this.getNewParts(key, info, rawParts.slice());
 
    const parts = _getNewParts.parts,
          duplicate = _getNewParts.duplicate;
 
    const newKey = this.implodeKey(parts);
    const oldKey = key;
    if (duplicate) {
      info.addHistory(`Satisfied from above by ${newKey}`);
      this.declareRename(info, rawParts, parts);
      return;
    }
 
    // update to the new key
    if (oldKey === newKey) {
      info.addHistory("Didn't hoist - conflicts above");
      this.setKey(info, oldKey, parts);
      return;
    }
 
    //
    this.declareRename(info, rawParts, parts);
    this.setKey(info, newKey, parts);
  }
 
  /**
   * Declare that a module has been hoisted and update our internal references.
   */
 
  declareRename(info, oldParts, newParts) {
    // go down the tree from our new position reserving our name
    this.taintParents(info, oldParts.slice(0, -1), newParts.length - 1);
  }
 
  /**
   * Crawl upwards through a list of ancestry parts and taint a package name.
   */
 
  taintParents(info, processParts, start) {
    for (let i = start; i < processParts.length; i++) {
      const parts = processParts.slice(0, i).concat(info.pkg.name);
      const key = this.implodeKey(parts);
 
      if (this.taintKey(key, info)) {
        info.addHistory(`Tainted ${key} to prevent collisions`);
      }
    }
  }
 
  /**
   * Update the key of a module and update our references.
   */
 
  setKey(info, newKey, parts) {
    const oldKey = info.key;
 
    info.key = newKey;
    info.parts = parts;
    this.tree.set(newKey, info);
 
    if (oldKey === newKey) {
      return;
    }
 
    info.previousKeys.push(newKey);
    info.addHistory(`New position = ${newKey}`);
  }
 
  /**
   * Perform a prepass and if there's multiple versions of the same package, hoist the one with
   * the most dependents to the top.
   */
 
  prepass(patterns) {
    patterns = this.resolver.dedupePatterns(patterns).sort();
 
    const occurences = {};
 
    // add an occuring package to the above data structure
    const add = (pattern, ancestry) => {
      const pkg = this.resolver.getStrictResolvedPattern(pattern);
      if (ancestry.indexOf(pkg) >= 0) {
        // prevent recursive dependencies
        return;
      }
 
      const ref = pkg._reference;
      invariant(ref, 'expected reference');
 
      const versions = occurences[pkg.name] = occurences[pkg.name] || {};
      const version = versions[pkg.version] = versions[pkg.version] || { occurences: new (_set || _load_set()).default(), pattern: pattern };
      version.occurences.add(ancestry[ancestry.length - 1]);
 
      for (const depPattern of ref.dependencies) {
        add(depPattern, ancestry.concat(pkg));
      }
    };
 
    // get a list of root package names since we can't hoist other dependencies to these spots!
    const rootPackageNames = new (_set || _load_set()).default();
    for (const pattern of patterns) {
      const pkg = this.resolver.getStrictResolvedPattern(pattern);
      rootPackageNames.add(pkg.name);
    }
 
    // seed occurences
    for (const pattern of patterns) {
      add(pattern, []);
    }
 
    for (const packageName of (0, (_keys || _load_keys()).default)(occurences).sort()) {
      const versionOccurences = occurences[packageName];
      const versions = (0, (_keys || _load_keys()).default)(versionOccurences);
 
      if (versions.length === 1) {
        // only one package type so we'll hoist this to the top anyway
        continue;
      }
 
      if (this.tree.get(packageName)) {
        // a transitive dependency of a previously hoisted dependency exists
        continue;
      }
 
      if (rootPackageNames.has(packageName)) {
        // can't replace top level packages
        continue;
      }
 
      let mostOccurenceCount;
      let mostOccurencePattern;
      for (const version of (0, (_keys || _load_keys()).default)(versionOccurences).sort()) {
        var _versionOccurences$ve = versionOccurences[version];
        const occurences = _versionOccurences$ve.occurences,
              pattern = _versionOccurences$ve.pattern;
 
        const occurenceCount = occurences.size;
 
        if (!mostOccurenceCount || occurenceCount > mostOccurenceCount) {
          mostOccurenceCount = occurenceCount;
          mostOccurencePattern = pattern;
        }
      }
      invariant(mostOccurencePattern, 'expected most occuring pattern');
      invariant(mostOccurenceCount, 'expected most occuring count');
 
      // only hoist this module if it occured more than once
      if (mostOccurenceCount > 1) {
        this._seed(mostOccurencePattern);
      }
    }
  }
 
  /**
   * Produce a flattened list of module locations and manifests.
   */
 
  init() {
    const flatTree = [];
 
    //
    for (const _ref7 of this.tree.entries()) {
      var _ref8 = (0, (_slicedToArray2 || _load_slicedToArray()).default)(_ref7, 2);
 
      const key = _ref8[0];
      const info = _ref8[1];
 
      // decompress the location and push it to the flat tree. this path could be made
      const parts = [];
      const keyParts = key.split('#');
      for (let i = 0; i < keyParts.length; i++) {
        const key = keyParts.slice(0, i + 1).join('#');
        const hoisted = this.tree.get(key);
        invariant(hoisted, 'expected hoisted manifest');
        parts.push(this.config.getFolder(hoisted.pkg));
        parts.push(keyParts[i]);
      }
 
      if (this.config.modulesFolder) {
        // remove the first part which will be the folder name and replace it with a
        // hardcoded modules folder
        parts.shift();
        const modulesFolder = this.config.modulesFolder == null ? '' : this.config.modulesFolder;
        parts.unshift(modulesFolder);
      } else {
        // first part will be the registry-specific module folder
        const cwd = this.config.cwd == null ? '' : this.config.cwd;
        parts.unshift(cwd);
      }
 
      const loc = path.join.apply(path, parts);
      flatTree.push([loc, info]);
    }
 
    // remove ignored modules from the tree
    const visibleFlatTree = [];
    for (const _ref9 of flatTree) {
      var _ref10 = (0, (_slicedToArray2 || _load_slicedToArray()).default)(_ref9, 2);
 
      const loc = _ref10[0];
      const info = _ref10[1];
 
      const ref = info.pkg._reference;
      invariant(ref, 'expected reference');
 
      if (info.isIgnored) {
        info.addHistory('Deleted as this module was ignored');
      } else {
        visibleFlatTree.push([loc, info]);
      }
    }
    return visibleFlatTree;
  }
}
 
exports.default = PackageHoister;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
 
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
1
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _promise;
 
function _load_promise() {
  return _promise = _interopRequireDefault(require('babel-runtime/core-js/promise'));
}
 
var _extends2;
 
function _load_extends() {
  return _extends2 = _interopRequireDefault(require('babel-runtime/helpers/extends'));
}
 
var _stringify;
 
function _load_stringify() {
  return _stringify = _interopRequireDefault(require('babel-runtime/core-js/json/stringify'));
}
 
var _slicedToArray2;
 
function _load_slicedToArray() {
  return _slicedToArray2 = _interopRequireDefault(require('babel-runtime/helpers/slicedToArray'));
}
 
var _map;
 
function _load_map() {
  return _map = _interopRequireDefault(require('babel-runtime/core-js/map'));
}
 
var _set;
 
function _load_set() {
  return _set = _interopRequireDefault(require('babel-runtime/core-js/set'));
}
 
var _asyncToGenerator2;
 
function _load_asyncToGenerator() {
  return _asyncToGenerator2 = _interopRequireDefault(require('babel-runtime/helpers/asyncToGenerator'));
}
 
var _executeLifecycleScript;
 
function _load_executeLifecycleScript() {
  return _executeLifecycleScript = _interopRequireDefault(require('./util/execute-lifecycle-script.js'));
}
 
var _fs;
 
function _load_fs() {
  return _fs = _interopRequireWildcard(require('./util/fs.js'));
}
 
var _constants;
 
function _load_constants() {
  return _constants = _interopRequireWildcard(require('./constants.js'));
}
 
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
const invariant = require('invariant');
const path = require('path');
 
const INSTALL_STAGES = ['preinstall', 'install', 'postinstall'];
 
class PackageInstallScripts {
  constructor(config, resolver, force) {
    this.installed = 0;
    this.resolver = resolver;
    this.reporter = config.reporter;
    this.config = config;
    this.force = force;
  }
 
  getInstallCommands(pkg) {
    const scripts = pkg.scripts;
    if (scripts) {
      const cmds = [];
      for (const stage of INSTALL_STAGES) {
        const cmd = scripts[stage];
        if (cmd) {
          cmds.push([stage, cmd]);
        }
      }
      return cmds;
    } else {
      return [];
    }
  }
 
  walk(loc) {
    var _this = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      const files = yield (_fs || _load_fs()).walk(loc, null, new (_set || _load_set()).default(_this.config.registryFolders));
      const mtimes = new (_map || _load_map()).default();
      for (const file of files) {
        mtimes.set(file.relative, file.mtime);
      }
      return mtimes;
    })();
  }
 
  saveBuildArtifacts(loc, pkg, beforeFiles, spinner) {
    var _this2 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      const afterFiles = yield _this2.walk(loc);
 
      // work out what files have been created/modified
      const buildArtifacts = [];
      for (const _ref of afterFiles) {
        var _ref2 = (0, (_slicedToArray2 || _load_slicedToArray()).default)(_ref, 2);
 
        const file = _ref2[0];
        const mtime = _ref2[1];
 
        if (!beforeFiles.has(file) || beforeFiles.get(file) !== mtime) {
          buildArtifacts.push(file);
        }
      }
 
      if (!buildArtifacts.length) {
        // nothing else to do here since we have no build artifacts
        return;
      }
 
      // if the process is killed while copying over build artifacts then we'll leave
      // the cache in a bad state. remove the metadata file and add it back once we've
      // done our copies to ensure cache integrity.
      const cachedLoc = _this2.config.generateHardModulePath(pkg._reference, true);
      const metadata = yield _this2.config.readPackageMetadata(cachedLoc);
      metadata.artifacts = buildArtifacts;
 
      const metadataLoc = path.join(cachedLoc, (_constants || _load_constants()).METADATA_FILENAME);
      yield (_fs || _load_fs()).writeFile(metadataLoc, (0, (_stringify || _load_stringify()).default)((0, (_extends2 || _load_extends()).default)({}, metadata, {
 
        // config.readPackageMetadata also returns the package manifest but that's not in the original
        // metadata json
        package: undefined
      }), null, '  '));
    })();
  }
 
  install(cmds, pkg, spinner) {
    var _this3 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      const ref = pkg._reference;
      invariant(ref, 'expected reference');
      const loc = _this3.config.generateHardModulePath(ref);
 
      try {
        for (const _ref3 of cmds) {
          var _ref4 = (0, (_slicedToArray2 || _load_slicedToArray()).default)(_ref3, 2);
 
          const stage = _ref4[0];
          const cmd = _ref4[1];
 
          yield (0, (_executeLifecycleScript || _load_executeLifecycleScript()).default)(stage, _this3.config, loc, cmd, spinner);
        }
      } catch (err) {
        err.message = `${loc}: ${err.message}`;
 
        invariant(ref, 'expected reference');
 
        if (ref.optional) {
          ref.ignore = true;
          _this3.reporter.warn(_this3.reporter.lang('optionalModuleScriptFail', err.message));
          _this3.reporter.info(_this3.reporter.lang('optionalModuleFail'));
 
          // Cleanup node_modules
          try {
            yield (_fs || _load_fs()).unlink(loc);
          } catch (e) {
            _this3.reporter.error(_this3.reporter.lang('optionalModuleCleanupFail', e.message));
          }
        } else {
          throw err;
        }
      }
    })();
  }
 
  packageCanBeInstalled(pkg) {
    const cmds = this.getInstallCommands(pkg);
    if (!cmds.length) {
      return false;
    }
    const ref = pkg._reference;
    invariant(ref, 'Missing package reference');
    if (!ref.fresh && !this.force) {
      // this package hasn't been touched
      return false;
    }
 
    // we haven't actually written this module out
    if (ref.ignore) {
      return false;
    }
    return true;
  }
 
  runCommand(spinner, pkg) {
    var _this4 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      const cmds = _this4.getInstallCommands(pkg);
      spinner.setPrefix(++_this4.installed, pkg.name);
      yield _this4.install(cmds, pkg, spinner);
    })();
  }
 
  // detect if there is a circularDependency in the dependency tree
  detectCircularDependencies(root, seenManifests, pkg) {
    const ref = pkg._reference;
    invariant(ref, 'expected reference');
 
    const deps = ref.dependencies;
    for (const dep of deps) {
      const pkgDep = this.resolver.getStrictResolvedPattern(dep);
      if (seenManifests.has(pkgDep)) {
        // there is a cycle but not with the root
        continue;
      }
      seenManifests.add(pkgDep);
      // found a dependency pointing to root
      if (pkgDep == root) {
        return true;
      }
      if (this.detectCircularDependencies(root, seenManifests, pkgDep)) {
        return true;
      }
    }
    return false;
  }
 
  // find the next package to be installed
  findInstallablePackage(workQueue, installed) {
    for (const pkg of workQueue) {
      const ref = pkg._reference;
      invariant(ref, 'expected reference');
      const deps = ref.dependencies;
 
      let dependenciesFullfilled = true;
      for (const dep of deps) {
        const pkgDep = this.resolver.getStrictResolvedPattern(dep);
        if (!installed.has(pkgDep)) {
          dependenciesFullfilled = false;
          break;
        }
      }
 
      // all depedencies are installed
      if (dependenciesFullfilled) {
        return pkg;
      }
 
      // detect circular dependency, mark this pkg as installable to break the circle
      if (this.detectCircularDependencies(pkg, new (_set || _load_set()).default(), pkg)) {
        return pkg;
      }
    }
    return null;
  }
 
  worker(spinner, workQueue, installed, waitQueue) {
    var _this5 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      while (true) {
        // No more work to be done
        if (workQueue.size == 0) {
          break;
        }
 
        // find a installable package
        const pkg = _this5.findInstallablePackage(workQueue, installed);
 
        // can't find a package to install, register into waitQueue
        if (pkg == null) {
          spinner.clear();
          yield new (_promise || _load_promise()).default(function (resolve) {
            return waitQueue.add(resolve);
          });
          continue;
        }
 
        // found a package to install
        workQueue.delete(pkg);
        if (_this5.packageCanBeInstalled(pkg)) {
          yield _this5.runCommand(spinner, pkg);
        }
        installed.add(pkg);
        for (const workerResolve of waitQueue) {
          workerResolve();
        }
        waitQueue.clear();
      }
    })();
  }
 
  init(seedPatterns) {
    var _this6 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      const workQueue = new (_set || _load_set()).default();
      const installed = new (_set || _load_set()).default();
      const pkgs = _this6.resolver.getTopologicalManifests(seedPatterns);
      let installablePkgs = 0;
      // A map to keep track of what files exist before installation
      const beforeFilesMap = new (_map || _load_map()).default();
      for (const pkg of pkgs) {
        if (_this6.packageCanBeInstalled(pkg)) {
          const ref = pkg._reference;
          invariant(ref, 'expected reference');
          const loc = _this6.config.generateHardModulePath(ref);
          beforeFilesMap.set(loc, (yield _this6.walk(loc)));
          installablePkgs += 1;
        }
        workQueue.add(pkg);
      }
 
      // waitQueue acts like a semaphore to allow workers to register to be notified
      // when there are more work added to the work queue
      const waitQueue = new (_set || _load_set()).default();
      const workers = [];
 
      const set = _this6.reporter.activitySet(installablePkgs, Math.min((_constants || _load_constants()).CHILD_CONCURRENCY, workQueue.size));
 
      for (const spinner of set.spinners) {
        workers.push(_this6.worker(spinner, workQueue, installed, waitQueue));
      }
 
      yield (_promise || _load_promise()).default.all(workers);
 
      // cache all build artifacts
      for (const pkg of pkgs) {
        if (_this6.packageCanBeInstalled(pkg)) {
          const ref = pkg._reference;
          invariant(ref, 'expected reference');
          const loc = _this6.config.generateHardModulePath(ref);
          const beforeFiles = beforeFilesMap.get(loc);
          invariant(beforeFiles, 'files before installation should always be recorded');
          yield _this6.saveBuildArtifacts(loc, pkg, beforeFiles, set.spinners[0]);
        }
      }
 
      set.end();
    })();
  }
}
exports.default = PackageInstallScripts;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
 
 
1
 
 
1
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
1
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
1
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
1
1
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.linkBin = undefined;
 
var _from;
 
function _load_from() {
  return _from = _interopRequireDefault(require('babel-runtime/core-js/array/from'));
}
 
var _set;
 
function _load_set() {
  return _set = _interopRequireDefault(require('babel-runtime/core-js/set'));
}
 
var _map;
 
function _load_map() {
  return _map = _interopRequireDefault(require('babel-runtime/core-js/map'));
}
 
var _promise;
 
function _load_promise() {
  return _promise = _interopRequireDefault(require('babel-runtime/core-js/promise'));
}
 
var _keys;
 
function _load_keys() {
  return _keys = _interopRequireDefault(require('babel-runtime/core-js/object/keys'));
}
 
var _slicedToArray2;
 
function _load_slicedToArray() {
  return _slicedToArray2 = _interopRequireDefault(require('babel-runtime/helpers/slicedToArray'));
}
 
var _asyncToGenerator2;
 
function _load_asyncToGenerator() {
  return _asyncToGenerator2 = _interopRequireDefault(require('babel-runtime/helpers/asyncToGenerator'));
}
 
let linkBin = exports.linkBin = (() => {
  var _ref = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* (src, dest) {
    if (process.platform === 'win32') {
      const unlockMutex = yield (0, (_mutex || _load_mutex()).default)(src);
      try {
        yield cmdShim(src, dest);
      } finally {
        unlockMutex();
      }
    } else {
      yield (_fs || _load_fs()).mkdirp(path.dirname(dest));
      yield (_fs || _load_fs()).symlink(src, dest);
      yield (_fs || _load_fs()).chmod(dest, '755');
    }
  });
 
  return function linkBin(_x, _x2) {
    return _ref.apply(this, arguments);
  };
})();
 
var _packageHoister;
 
function _load_packageHoister() {
  return _packageHoister = _interopRequireDefault(require('./package-hoister.js'));
}
 
var _constants;
 
function _load_constants() {
  return _constants = _interopRequireWildcard(require('./constants.js'));
}
 
var _promise2;
 
function _load_promise2() {
  return _promise2 = _interopRequireWildcard(require('./util/promise.js'));
}
 
var _misc;
 
function _load_misc() {
  return _misc = require('./util/misc.js');
}
 
var _fs;
 
function _load_fs() {
  return _fs = _interopRequireWildcard(require('./util/fs.js'));
}
 
var _mutex;
 
function _load_mutex() {
  return _mutex = _interopRequireDefault(require('./util/mutex.js'));
}
 
function _interopRequireWildcard(obj) { Eif (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
const invariant = require('invariant');
const cmdShim = (_promise2 || _load_promise2()).promisify(require('cmd-shim'));
const semver = require('semver');
const path = require('path');
 
class PackageLinker {
  constructor(config, resolver) {
    this.resolver = resolver;
    this.reporter = config.reporter;
    this.config = config;
  }
 
  linkSelfDependencies(pkg, pkgLoc, targetBinLoc) {
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      targetBinLoc = yield (_fs || _load_fs()).realpath(targetBinLoc);
      pkgLoc = yield (_fs || _load_fs()).realpath(pkgLoc);
      for (const _ref2 of (0, (_misc || _load_misc()).entries)(pkg.bin)) {
        var _ref3 = (0, (_slicedToArray2 || _load_slicedToArray()).default)(_ref2, 2);
 
        const scriptName = _ref3[0];
        const scriptCmd = _ref3[1];
 
        const dest = path.join(targetBinLoc, scriptName);
        const src = path.join(pkgLoc, scriptCmd);
        if (!(yield (_fs || _load_fs()).exists(src))) {
          // TODO maybe throw an error
          continue;
        }
        yield linkBin(src, dest);
      }
    })();
  }
 
  linkBinDependencies(pkg, dir) {
    var _this = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      const deps = [];
 
      const ref = pkg._reference;
      invariant(ref, 'Package reference is missing');
 
      const remote = pkg._remote;
      invariant(remote, 'Package remote is missing');
 
      // link up `bin scripts` in `dependencies`
      for (const pattern of ref.dependencies) {
        const dep = _this.resolver.getStrictResolvedPattern(pattern);
        if (dep.bin && (0, (_keys || _load_keys()).default)(dep.bin).length) {
          deps.push({ dep: dep, loc: _this.config.generateHardModulePath(dep._reference) });
        }
      }
 
      // link up the `bin` scripts in bundled dependencies
      if (pkg.bundleDependencies) {
        for (const depName of pkg.bundleDependencies) {
          const loc = path.join(_this.config.generateHardModulePath(ref), _this.config.getFolder(pkg), depName);
 
          const dep = yield _this.config.readManifest(loc, remote.registry);
 
          if (dep.bin && (0, (_keys || _load_keys()).default)(dep.bin).length) {
            deps.push({ dep: dep, loc: loc });
          }
        }
      }
 
      // no deps to link
      if (!deps.length) {
        return;
      }
 
      // ensure our .bin file we're writing these to exists
      const binLoc = path.join(dir, '.bin');
      yield (_fs || _load_fs()).mkdirp(binLoc);
 
      // write the executables
      for (const _ref4 of deps) {
        const dep = _ref4.dep;
        const loc = _ref4.loc;
 
        yield _this.linkSelfDependencies(dep, loc, binLoc);
      }
    })();
  }
 
  getFlatHoistedTree(patterns) {
    const hoister = new (_packageHoister || _load_packageHoister()).default(this.config, this.resolver);
    hoister.seed(patterns);
    return (_promise || _load_promise()).default.resolve(hoister.init());
  }
 
  copyModules(patterns, linkDuplicates) {
    var _this2 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      let flatTree = yield _this2.getFlatHoistedTree(patterns);
 
      // sorted tree makes file creation and copying not to interfere with each other
      flatTree = flatTree.sort(function (dep1, dep2) {
        return dep1[0].localeCompare(dep2[0]);
      });
 
      // list of artifacts in modules to remove from extraneous removal
      const artifactFiles = [];
 
      const copyQueue = new (_map || _load_map()).default();
      const hardlinkQueue = new (_map || _load_map()).default();
      const hardlinksEnabled = linkDuplicates && (yield (_fs || _load_fs()).hardlinksWork(_this2.config.cwd));
 
      const copiedSrcs = new (_map || _load_map()).default();
      for (const _ref5 of flatTree) {
        var _ref6 = (0, (_slicedToArray2 || _load_slicedToArray()).default)(_ref5, 2);
 
        const dest = _ref6[0];
        var _ref6$ = _ref6[1];
        const pkg = _ref6$.pkg;
        const src = _ref6$.loc;
 
        const ref = pkg._reference;
        invariant(ref, 'expected package reference');
        ref.setLocation(dest);
 
        // get a list of build artifacts contained in this module so we can prevent them from being marked as
        // extraneous
        const metadata = yield _this2.config.readPackageMetadata(src);
        for (const file of metadata.artifacts) {
          artifactFiles.push(path.join(dest, file));
        }
 
        const copiedDest = copiedSrcs.get(src);
        if (!copiedDest) {
          if (hardlinksEnabled) {
            copiedSrcs.set(src, dest);
          }
          copyQueue.set(dest, {
            src: src,
            dest: dest,
            onFresh: function onFresh() {
              if (ref) {
                ref.setFresh(true);
              }
            }
          });
        } else {
          hardlinkQueue.set(dest, {
            src: copiedDest,
            dest: dest,
            onFresh: function onFresh() {
              if (ref) {
                ref.setFresh(true);
              }
            }
          });
        }
      }
 
      // keep track of all scoped paths to remove empty scopes after copy
      const scopedPaths = new (_set || _load_set()).default();
 
      // register root & scoped packages as being possibly extraneous
      const possibleExtraneous = new (_set || _load_set()).default();
      for (const folder of _this2.config.registryFolders) {
        const loc = path.join(_this2.config.cwd, folder);
 
        if (yield (_fs || _load_fs()).exists(loc)) {
          const files = yield (_fs || _load_fs()).readdir(loc);
          let filepath;
          for (const file of files) {
            filepath = path.join(loc, file);
            if (file[0] === '@') {
              // it's a scope, not a package
              scopedPaths.add(filepath);
              const subfiles = yield (_fs || _load_fs()).readdir(filepath);
              for (const subfile of subfiles) {
                possibleExtraneous.add(path.join(filepath, subfile));
              }
            } else {
              possibleExtraneous.add(filepath);
            }
          }
        }
      }
 
      // linked modules
      for (const loc of possibleExtraneous) {
        const stat = yield (_fs || _load_fs()).lstat(loc);
        if (stat.isSymbolicLink()) {
          possibleExtraneous.delete(loc);
          copyQueue.delete(loc);
        }
      }
 
      //
      let tick;
      yield (_fs || _load_fs()).copyBulk((0, (_from || _load_from()).default)(copyQueue.values()), _this2.reporter, {
        possibleExtraneous: possibleExtraneous,
        artifactFiles: artifactFiles,
 
        ignoreBasenames: [(_constants || _load_constants()).METADATA_FILENAME, (_constants || _load_constants()).TARBALL_FILENAME],
 
        onStart: function onStart(num) {
          tick = _this2.reporter.progress(num);
        },
 
        onProgress: function onProgress(src) {
          if (tick) {
            tick(src);
          }
        }
      });
      yield (_fs || _load_fs()).hardlinkBulk((0, (_from || _load_from()).default)(hardlinkQueue.values()), _this2.reporter, {
        possibleExtraneous: possibleExtraneous,
        artifactFiles: artifactFiles,
 
        onStart: function onStart(num) {
          tick = _this2.reporter.progress(num);
        },
 
        onProgress: function onProgress(src) {
          if (tick) {
            tick(src);
          }
        }
      });
 
      // remove all extraneous files that weren't in the tree
      for (const loc of possibleExtraneous) {
        _this2.reporter.verbose(_this2.reporter.lang('verboseFileRemoveExtraneous', loc));
        yield (_fs || _load_fs()).unlink(loc);
      }
 
      // remove any empty scoped directories
      for (const scopedPath of scopedPaths) {
        const files = yield (_fs || _load_fs()).readdir(scopedPath);
        if (files.length === 0) {
          yield (_fs || _load_fs()).unlink(scopedPath);
        }
      }
 
      //
      if (_this2.config.binLinks) {
        const tickBin = _this2.reporter.progress(flatTree.length);
        yield (_promise2 || _load_promise2()).queue(flatTree, (() => {
          var _ref8 = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* (_ref7) {
            var _ref9 = (0, (_slicedToArray2 || _load_slicedToArray()).default)(_ref7, 2);
 
            let dest = _ref9[0],
                pkg = _ref9[1].pkg;
 
            const binLoc = path.join(dest, _this2.config.getFolder(pkg));
            yield _this2.linkBinDependencies(pkg, binLoc);
            tickBin(dest);
          });
 
          return function (_x3) {
            return _ref8.apply(this, arguments);
          };
        })(), 4);
      }
    })();
  }
 
  resolvePeerModules() {
    for (const pkg of this.resolver.getManifests()) {
      this._resolvePeerModules(pkg);
    }
  }
 
  _resolvePeerModules(pkg) {
    const peerDeps = pkg.peerDependencies;
    if (!peerDeps) {
      return;
    }
 
    const ref = pkg._reference;
    invariant(ref, 'Package reference is missing');
 
    for (const name in peerDeps) {
      const range = peerDeps[name];
      const patterns = this.resolver.patternsByPackage[name] || [];
      const foundPattern = patterns.find(pattern => {
        const resolvedPattern = this.resolver.getResolvedPattern(pattern);
        return resolvedPattern ? this._satisfiesPeerDependency(range, resolvedPattern.version) : false;
      });
 
      if (foundPattern) {
        ref.addDependencies([foundPattern]);
      } else {
        const depError = patterns.length > 0 ? 'incorrectPeer' : 'unmetPeer';
        const pkgHuman = `${pkg.name}@${pkg.version}`,
              depHuman = `${name}@${range}`;
 
        this.reporter.warn(this.reporter.lang(depError, pkgHuman, depHuman));
      }
    }
  }
 
  _satisfiesPeerDependency(range, version) {
    return range === '*' || semver.satisfies(version, range, this.config.looseSemver);
  }
 
  init(patterns, linkDuplicates) {
    var _this3 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      _this3.resolvePeerModules();
      yield _this3.copyModules(patterns, linkDuplicates);
      yield _this3.saveAll(patterns);
    })();
  }
 
  save(pattern) {
    var _this4 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      const resolved = _this4.resolver.getResolvedPattern(pattern);
      invariant(resolved, `Couldn't find resolved name/version for ${pattern}`);
 
      const ref = resolved._reference;
      invariant(ref, 'Missing reference');
 
      //
      const src = _this4.config.generateHardModulePath(ref);
 
      // link bins
      if (_this4.config.binLinks && resolved.bin && (0, (_keys || _load_keys()).default)(resolved.bin).length && !ref.ignore) {
        const folder = _this4.config.modulesFolder || path.join(_this4.config.cwd, _this4.config.getFolder(resolved));
        const binLoc = path.join(folder, '.bin');
        yield (_fs || _load_fs()).mkdirp(binLoc);
        yield _this4.linkSelfDependencies(resolved, src, binLoc);
      }
    })();
  }
 
  saveAll(deps) {
    var _this5 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      deps = _this5.resolver.dedupePatterns(deps);
      yield (_promise2 || _load_promise2()).queue(deps, function (dep) {
        return _this5.save(dep);
      });
    })();
  }
}
exports.default = PackageLinker;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _slicedToArray2;
 
function _load_slicedToArray() {
  return _slicedToArray2 = _interopRequireDefault(require('babel-runtime/helpers/slicedToArray'));
}
 
var _misc;
 
function _load_misc() {
  return _misc = require('./util/misc.js');
}
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
class PackageReference {
  constructor(request, info, remote) {
    this.resolver = request.resolver;
    this.lockfile = request.lockfile;
    this.requests = [];
    this.config = request.config;
 
    this.registry = remote.registry;
    this.version = info.version;
    this.name = info.name;
    this.uid = info._uid;
 
    this.remote = remote;
 
    this.dependencies = [];
 
    this.permissions = {};
    this.patterns = [];
    this.optional = null;
    this.root = false;
    this.ignore = false;
    this.fresh = false;
    this.location = null;
    this.addRequest(request);
  }
 
  setFresh(fresh) {
    this.fresh = fresh;
  }
 
  setLocation(loc) {
    return this.location = loc;
  }
 
  addRequest(request) {
    this.requests.push(request);
 
    if (!request.parentRequest) {
      this.root = true;
    }
  }
 
  prune() {
    for (const selfPattern of this.patterns) {
      // remove ourselves from the resolver
      this.resolver.removePattern(selfPattern);
    }
  }
 
  addDependencies(deps) {
    this.dependencies = this.dependencies.concat(deps);
  }
 
  setPermission(key, val) {
    this.permissions[key] = val;
  }
 
  hasPermission(key) {
    if (key in this.permissions) {
      return this.permissions[key];
    } else {
      return false;
    }
  }
 
  addPattern(pattern, manifest) {
    this.resolver.addPattern(pattern, manifest);
 
    this.patterns.push(pattern);
 
    const shrunk = this.lockfile.getLocked(pattern);
    if (shrunk && shrunk.permissions) {
      for (const _ref of (0, (_misc || _load_misc()).entries)(shrunk.permissions)) {
        var _ref2 = (0, (_slicedToArray2 || _load_slicedToArray()).default)(_ref, 2);
 
        const key = _ref2[0];
        const perm = _ref2[1];
 
        this.setPermission(key, perm);
      }
    }
  }
 
  addOptional(optional) {
    if (this.optional == null) {
      // optional is uninitialised
      this.optional = optional;
    } else if (!optional) {
      // otherwise, ignore all subsequent optional assignments and only accept ones making
      // this not optional
      this.optional = false;
    }
  }
}
exports.default = PackageReference;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
 
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
1
 
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _promise;
 
function _load_promise() {
  return _promise = _interopRequireDefault(require('babel-runtime/core-js/promise'));
}
 
var _assign;
 
function _load_assign() {
  return _assign = _interopRequireDefault(require('babel-runtime/core-js/object/assign'));
}
 
var _asyncToGenerator2;
 
function _load_asyncToGenerator() {
  return _asyncToGenerator2 = _interopRequireDefault(require('babel-runtime/helpers/asyncToGenerator'));
}
 
var _slicedToArray2;
 
function _load_slicedToArray() {
  return _slicedToArray2 = _interopRequireDefault(require('babel-runtime/helpers/slicedToArray'));
}
 
var _validate;
 
function _load_validate() {
  return _validate = require('./util/normalize-manifest/validate.js');
}
 
var _wrapper;
 
function _load_wrapper() {
  return _wrapper = _interopRequireDefault(require('./lockfile/wrapper.js'));
}
 
var _packageReference;
 
function _load_packageReference() {
  return _packageReference = _interopRequireDefault(require('./package-reference.js'));
}
 
var _index;
 
function _load_index() {
  return _index = _interopRequireWildcard(require('./resolvers/index.js'));
}
 
var _index2;
 
function _load_index2() {
  return _index2 = require('./resolvers/index.js');
}
 
var _errors;
 
function _load_errors() {
  return _errors = require('./errors.js');
}
 
var _misc;
 
function _load_misc() {
  return _misc = require('./util/misc.js');
}
 
var _constants;
 
function _load_constants() {
  return _constants = _interopRequireWildcard(require('./constants.js'));
}
 
var _version;
 
function _load_version() {
  return _version = _interopRequireWildcard(require('./util/version.js'));
}
 
var _fs;
 
function _load_fs() {
  return _fs = _interopRequireWildcard(require('./util/fs.js'));
}
 
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
const path = require('path');
 
const invariant = require('invariant');
const semver = require('semver');
 
class PackageRequest {
  constructor(req, resolver) {
    this.parentRequest = req.parentRequest;
    this.lockfile = resolver.lockfile;
    this.registry = req.registry;
    this.reporter = resolver.reporter;
    this.resolver = resolver;
    this.optional = req.optional;
    this.pattern = req.pattern;
    this.config = resolver.config;
 
    resolver.usedRegistries.add(req.registry);
  }
 
  static getExoticResolver(pattern) {
    // TODO make this type more refined
    for (const _ref of (0, (_misc || _load_misc()).entries)((_index || _load_index()).exotics)) {
      var _ref2 = (0, (_slicedToArray2 || _load_slicedToArray()).default)(_ref, 2);
 
      const Resolver = _ref2[1];
 
      if (Resolver.isVersion(pattern)) {
        return Resolver;
      }
    }
    return null;
  }
 
  getParentNames() {
    const chain = [];
 
    let request = this.parentRequest;
    while (request) {
      const info = this.resolver.getStrictResolvedPattern(request.pattern);
      chain.unshift(info.name);
 
      request = request.parentRequest;
    }
 
    return chain;
  }
 
  getLocked(remoteType) {
    // always prioritise root lockfile
    const shrunk = this.lockfile.getLocked(this.pattern);
 
    if (shrunk && shrunk.resolved) {
      const resolvedParts = (_version || _load_version()).explodeHashedUrl(shrunk.resolved);
 
      return {
        name: shrunk.name,
        version: shrunk.version,
        _uid: shrunk.uid,
        _remote: {
          resolved: shrunk.resolved,
          type: remoteType,
          reference: resolvedParts.url,
          hash: resolvedParts.hash,
          registry: shrunk.registry
        },
        optionalDependencies: shrunk.optionalDependencies,
        dependencies: shrunk.dependencies
      };
    } else {
      return null;
    }
  }
 
  /**
   * If the input pattern matches a registry one then attempt to find it on the registry.
   * Otherwise fork off to an exotic resolver if one matches.
   */
 
  findVersionOnRegistry(pattern) {
    var _this = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      var _ref3 = yield _this.normalize(pattern);
 
      const range = _ref3.range,
            name = _ref3.name;
 
 
      const exoticResolver = PackageRequest.getExoticResolver(range);
      if (exoticResolver) {
        let data = yield _this.findExoticVersionInfo(exoticResolver, range);
 
        // clone data as we're manipulating it in place and this could be resolved multiple
        // times
        data = (0, (_assign || _load_assign()).default)({}, data);
 
        // this is so the returned package response uses the overridden name. ie. if the
        // package's actual name is `bar`, but it's been specified in the manifest like:
        //   "foo": "http://foo.com/bar.tar.gz"
        // then we use the foo name
        data.name = name;
 
        return data;
      }
 
      const Resolver = _this.getRegistryResolver();
      const resolver = new Resolver(_this, name, range);
      return resolver.resolve();
    })();
  }
 
  /**
   * Get the registry resolver associated with this package request.
   */
 
  getRegistryResolver() {
    const Resolver = (_index2 || _load_index2()).registries[this.registry];
    if (Resolver) {
      return Resolver;
    } else {
      throw new (_errors || _load_errors()).MessageError(this.reporter.lang('unknownRegistryResolver', this.registry));
    }
  }
 
  normalizeRange(pattern) {
    var _this2 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      if (pattern.includes(':') || pattern.includes('@') || PackageRequest.getExoticResolver(pattern)) {
        return (_promise || _load_promise()).default.resolve(pattern);
      }
 
      if (yield (_fs || _load_fs()).exists(path.join(_this2.config.cwd, pattern))) {
        return (_promise || _load_promise()).default.resolve(`file:${pattern}`);
      }
 
      return (_promise || _load_promise()).default.resolve(pattern);
    })();
  }
 
  normalize(pattern) {
    var _this3 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      var _PackageRequest$norma = PackageRequest.normalizePattern(pattern);
 
      const name = _PackageRequest$norma.name,
            range = _PackageRequest$norma.range,
            hasVersion = _PackageRequest$norma.hasVersion;
 
      const newRange = yield _this3.normalizeRange(range);
      return { name: name, range: newRange, hasVersion: hasVersion };
    })();
  }
 
  /**
   * Explode and normalize a pattern into it's name and range.
   */
 
  static normalizePattern(pattern) {
    let hasVersion = false;
    let range = 'latest';
    let name = pattern;
 
    // if we're a scope then remove the @ and add it back later
    let isScoped = false;
    if (name[0] === '@') {
      isScoped = true;
      name = name.slice(1);
    }
 
    // take first part as the name
    const parts = name.split('@');
    if (parts.length > 1) {
      name = parts.shift();
      range = parts.join('@');
 
      if (range) {
        hasVersion = true;
      } else {
        range = '*';
      }
    }
 
    // add back @ scope suffix
    if (isScoped) {
      name = `@${name}`;
    }
 
    return { name: name, range: range, hasVersion: hasVersion };
  }
 
  /**
   * Construct an exotic resolver instance with the input `ExoticResolver` and `range`.
   */
 
  findExoticVersionInfo(ExoticResolver, range) {
    const resolver = new ExoticResolver(this, range);
    return resolver.resolve();
  }
 
  /**
   * If the current pattern matches an exotic resolver then delegate to it or else try
   * the registry.
   */
 
  findVersionInfo() {
    var _this4 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      const exoticResolver = PackageRequest.getExoticResolver(_this4.pattern);
      if (exoticResolver) {
        return yield _this4.findExoticVersionInfo(exoticResolver, _this4.pattern);
      } else {
        return yield _this4.findVersionOnRegistry(_this4.pattern);
      }
    })();
  }
 
  reportResolvedRangeMatch(info, resolved) {}
 
  /**
   * TODO description
   */
 
  find() {
    var _this5 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      // find version info for this package pattern
      const info = yield _this5.findVersionInfo();
      if (!info) {
        throw new (_errors || _load_errors()).MessageError(_this5.reporter.lang('unknownPackage', _this5.pattern));
      }
 
      (0, (_validate || _load_validate()).cleanDependencies)(info, false, _this5.reporter, function () {
        // swallow warnings
      });
 
      // check if while we were resolving this dep we've already resolved one that satisfies
      // the same range
 
      var _PackageRequest$norma2 = PackageRequest.normalizePattern(_this5.pattern);
 
      const range = _PackageRequest$norma2.range,
            name = _PackageRequest$norma2.name;
 
      const resolved = _this5.resolver.getHighestRangeVersionMatch(name, range);
      if (resolved) {
        _this5.reportResolvedRangeMatch(info, resolved);
        const ref = resolved._reference;
        invariant(ref, 'Resolved package info has no package reference');
        ref.addRequest(_this5);
        ref.addPattern(_this5.pattern, resolved);
        return;
      }
 
      if (info.flat && !_this5.resolver.flat) {
        throw new (_errors || _load_errors()).MessageError(_this5.reporter.lang('flatGlobalError'));
      }
 
      // validate version info
      PackageRequest.validateVersionInfo(info, _this5.reporter);
 
      //
      const remote = info._remote;
      invariant(remote, 'Missing remote');
 
      // set package reference
      const ref = new (_packageReference || _load_packageReference()).default(_this5, info, remote);
      ref.addPattern(_this5.pattern, info);
      ref.addOptional(_this5.optional);
      info._reference = ref;
      info._remote = remote;
 
      // start installation of dependencies
      const promises = [];
      const deps = [];
 
      // normal deps
      for (const depName in info.dependencies) {
        const depPattern = depName + '@' + info.dependencies[depName];
        deps.push(depPattern);
        promises.push(_this5.resolver.find({
          pattern: depPattern,
          registry: remote.registry,
          optional: false,
          parentRequest: _this5
        }));
      }
 
      // optional deps
      for (const depName in info.optionalDependencies) {
        const depPattern = depName + '@' + info.optionalDependencies[depName];
        deps.push(depPattern);
        promises.push(_this5.resolver.find({
          pattern: depPattern,
          registry: remote.registry,
          optional: true,
          parentRequest: _this5
        }));
      }
 
      yield (_promise || _load_promise()).default.all(promises);
      ref.addDependencies(deps);
 
      // Now that we have all dependencies, it's safe to propagate optional
      for (const otherRequest of ref.requests.slice(1)) {
        ref.addOptional(otherRequest.optional);
      }
    })();
  }
 
  /**
   * TODO description
   */
 
  static validateVersionInfo(info, reporter) {
    // human readable name to use in errors
    const human = `${info.name}@${info.version}`;
 
    info.version = PackageRequest.getPackageVersion(info);
 
    for (const key of (_constants || _load_constants()).REQUIRED_PACKAGE_KEYS) {
      if (!info[key]) {
        throw new (_errors || _load_errors()).MessageError(reporter.lang('missingRequiredPackageKey', human, key));
      }
    }
  }
 
  /**
   * Returns the package version if present, else defaults to the uid
   */
 
  static getPackageVersion(info) {
    // TODO possibly reconsider this behaviour
    return info.version === undefined ? info._uid : info.version;
  }
 
  /**
   * Gets all of the outdated packages and sorts them appropriately
   */
 
  static getOutdatedPackages(lockfile, install, config, reporter) {
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      var _ref4 = yield install.fetchRequestFromCwd();
 
      const depReqPatterns = _ref4.requests;
 
 
      const deps = yield (_promise || _load_promise()).default.all(depReqPatterns.map((() => {
        var _ref6 = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* (_ref5) {
          let pattern = _ref5.pattern,
              hint = _ref5.hint;
 
          const locked = lockfile.getLocked(pattern);
          if (!locked) {
            throw new (_errors || _load_errors()).MessageError(reporter.lang('lockfileOutdated'));
          }
 
          const name = locked.name,
                current = locked.version;
 
          let latest = '';
          let wanted = '';
          let url = '';
 
          const normalized = PackageRequest.normalizePattern(pattern);
 
          if (PackageRequest.getExoticResolver(pattern) || PackageRequest.getExoticResolver(normalized.range)) {
            latest = wanted = 'exotic';
            url = normalized.range;
          } else {
            const registry = config.registries[locked.registry];
 
            var _ref7 = yield registry.checkOutdated(config, name, normalized.range);
 
            latest = _ref7.latest;
            wanted = _ref7.wanted;
            url = _ref7.url;
          }
 
          return { name: name, current: current, wanted: wanted, latest: latest, url: url, hint: hint };
        });
 
        return function (_x) {
          return _ref6.apply(this, arguments);
        };
      })()));
 
      // Make sure to always output `exotic` versions to be compatible with npm
      const isDepOld = function isDepOld(_ref8) {
        let current = _ref8.current,
            latest = _ref8.latest,
            wanted = _ref8.wanted;
        return latest === 'exotic' || latest !== 'exotic' && (semver.lt(current, wanted) || semver.lt(current, latest));
      };
      const orderByName = function orderByName(depA, depB) {
        return depA.name.localeCompare(depB.name);
      };
 
      return deps.filter(isDepOld).sort(orderByName);
    })();
  }
}
exports.default = PackageRequest;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
 
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _asyncToGenerator2;
 
function _load_asyncToGenerator() {
  return _asyncToGenerator2 = _interopRequireDefault(require('babel-runtime/helpers/asyncToGenerator'));
}
 
var _promise;
 
function _load_promise() {
  return _promise = _interopRequireDefault(require('babel-runtime/core-js/promise'));
}
 
var _set;
 
function _load_set() {
  return _set = _interopRequireDefault(require('babel-runtime/core-js/set'));
}
 
var _packageRequest;
 
function _load_packageRequest() {
  return _packageRequest = _interopRequireDefault(require('./package-request.js'));
}
 
var _requestManager;
 
function _load_requestManager() {
  return _requestManager = _interopRequireDefault(require('./util/request-manager.js'));
}
 
var _blockingQueue;
 
function _load_blockingQueue() {
  return _blockingQueue = _interopRequireDefault(require('./util/blocking-queue.js'));
}
 
var _wrapper;
 
function _load_wrapper() {
  return _wrapper = _interopRequireDefault(require('./lockfile/wrapper.js'));
}
 
var _map;
 
function _load_map() {
  return _map = _interopRequireDefault(require('./util/map.js'));
}
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
const invariant = require('invariant');
const semver = require('semver');
 
class PackageResolver {
  constructor(config, lockfile) {
    this.patternsByPackage = (0, (_map || _load_map()).default)();
    this.fetchingPatterns = (0, (_map || _load_map()).default)();
    this.fetchingQueue = new (_blockingQueue || _load_blockingQueue()).default('resolver fetching');
    this.newPatterns = [];
    this.patterns = (0, (_map || _load_map()).default)();
    this.usedRegistries = new (_set || _load_set()).default();
    this.flat = false;
 
    this.reporter = config.reporter;
    this.lockfile = lockfile;
    this.config = config;
  }
 
  // whether the dependency graph will be flattened
 
 
  // list of registries that have been used in this resolution
 
 
  // activity monitor
 
 
  // patterns we've already resolved or are in the process of resolving
 
 
  // new patterns that didn't exist in the lockfile
 
 
  // TODO
 
 
  // these are patterns that the package resolver was seeded with. these are required in
  // order to resolve top level peerDependencies
 
 
  // manages and throttles json api http requests
 
 
  // list of patterns associated with a package
 
 
  // lockfile instance which we can use to retrieve version info
 
 
  // a map of dependency patterns to packages
 
 
  // reporter instance, abstracts out display logic
 
 
  // environment specific config methods and options
 
 
  /**
   * TODO description
   */
 
  isNewPattern(pattern) {
    return this.newPatterns.indexOf(pattern) >= 0;
  }
 
  /**
   * TODO description
   */
 
  updateManifest(ref, newPkg) {
    // inherit fields
    const oldPkg = this.patterns[ref.patterns[0]];
    newPkg._reference = ref;
    newPkg._remote = ref.remote;
    newPkg.name = oldPkg.name;
 
    // update patterns
    for (const pattern of ref.patterns) {
      this.patterns[pattern] = newPkg;
    }
 
    return (_promise || _load_promise()).default.resolve();
  }
 
  /**
   * Given a list of patterns, dedupe them to a list of unique patterns.
   */
 
  dedupePatterns(patterns) {
    const deduped = [];
    const seen = new (_set || _load_set()).default();
 
    for (const pattern of patterns) {
      const info = this.getResolvedPattern(pattern);
      if (seen.has(info)) {
        continue;
      }
 
      seen.add(info);
      deduped.push(pattern);
    }
 
    return deduped;
  }
 
  /**
   * Get a list of all manifests by topological order.
   */
 
  getTopologicalManifests(seedPatterns) {
    const pkgs = new (_set || _load_set()).default();
    const skip = new (_set || _load_set()).default();
 
    const add = seedPatterns => {
      for (const pattern of seedPatterns) {
        const pkg = this.getStrictResolvedPattern(pattern);
        if (skip.has(pkg)) {
          continue;
        }
 
        const ref = pkg._reference;
        invariant(ref, 'expected reference');
        skip.add(pkg);
        add(ref.dependencies);
        pkgs.add(pkg);
      }
    };
 
    add(seedPatterns);
 
    return pkgs;
  }
 
  /**
   * Get a list of all manifests by level sort order.
   */
 
  getLevelOrderManifests(seedPatterns) {
    const pkgs = new (_set || _load_set()).default();
    const skip = new (_set || _load_set()).default();
 
    const add = seedPatterns => {
      const refs = [];
 
      for (const pattern of seedPatterns) {
        const pkg = this.getStrictResolvedPattern(pattern);
        if (skip.has(pkg)) {
          continue;
        }
 
        const ref = pkg._reference;
        invariant(ref, 'expected reference');
 
        refs.push(ref);
        skip.add(pkg);
        pkgs.add(pkg);
      }
 
      for (const ref of refs) {
        add(ref.dependencies);
      }
    };
 
    add(seedPatterns);
 
    return pkgs;
  }
 
  /**
   * Get a list of all package names in the depenency graph.
   */
 
  getAllDependencyNamesByLevelOrder(seedPatterns) {
    const names = new (_set || _load_set()).default();
    for (const _ref of this.getLevelOrderManifests(seedPatterns)) {
      const name = _ref.name;
 
      names.add(name);
    }
    return names;
  }
 
  /**
   * Retrieve all the package info stored for this package name.
   */
 
  getAllInfoForPackageName(name) {
    const infos = [];
    const seen = new (_set || _load_set()).default();
 
    for (const pattern of this.patternsByPackage[name]) {
      const info = this.patterns[pattern];
      if (seen.has(info)) {
        continue;
      }
 
      seen.add(info);
      infos.push(info);
    }
 
    return infos;
  }
 
  /**
   * Get a flat list of all package references.
   */
 
  getPackageReferences() {
    const refs = [];
 
    for (const manifest of this.getManifests()) {
      const ref = manifest._reference;
      if (ref) {
        refs.push(ref);
      }
    }
 
    return refs;
  }
 
  /**
   * Get a flat list of all package info.
   */
 
  getManifests() {
    const infos = [];
    const seen = new (_set || _load_set()).default();
 
    for (const pattern in this.patterns) {
      const info = this.patterns[pattern];
      if (seen.has(info)) {
        continue;
      }
 
      infos.push(info);
      seen.add(info);
    }
 
    return infos;
  }
 
  /**
   * replace pattern in resolver, e.g. `name` is replaced with `name@^1.0.1`
   */
  replacePattern(pattern, newPattern) {
    const pkg = this.getResolvedPattern(pattern);
    invariant(pkg, `missing package ${pattern}`);
    const ref = pkg._reference;
    invariant(ref, 'expected package reference');
    ref.patterns = [newPattern];
    this.newPatterns.splice(this.newPatterns.indexOf(pattern), 1, newPattern);
    this.addPattern(newPattern, pkg);
    this.removePattern(pattern);
  }
 
  /**
   * Make all versions of this package resolve to it.
   */
 
  collapseAllVersionsOfPackage(name, version) {
    const patterns = this.dedupePatterns(this.patternsByPackage[name]);
    const human = `${name}@${version}`;
 
    // get manifest that matches the version we're collapsing too
    let collapseToReference;
    let collapseToManifest;
    let collapseToPattern;
    for (const pattern of patterns) {
      const _manifest = this.patterns[pattern];
      if (_manifest.version === version) {
        collapseToReference = _manifest._reference;
        collapseToManifest = _manifest;
        collapseToPattern = pattern;
        break;
      }
    }
    invariant(collapseToReference && collapseToManifest && collapseToPattern, `Couldn't find package manifest for ${human}`);
 
    for (const pattern of patterns) {
      // don't touch the pattern we're collapsing to
      if (pattern === collapseToPattern) {
        continue;
      }
 
      // remove this pattern
      const ref = this.getStrictResolvedPattern(pattern)._reference;
      invariant(ref, 'expected package reference');
      const refPatterns = ref.patterns.slice();
      ref.prune();
 
      // add pattern to the manifest we're collapsing to
      for (const pattern of refPatterns) {
        collapseToReference.addPattern(pattern, collapseToManifest);
      }
    }
 
    return collapseToPattern;
  }
 
  /**
   * TODO description
   */
 
  addPattern(pattern, info) {
    this.patterns[pattern] = info;
 
    const byName = this.patternsByPackage[info.name] = this.patternsByPackage[info.name] || [];
    byName.push(pattern);
  }
 
  /**
   * TODO description
   */
 
  removePattern(pattern) {
    const pkg = this.patterns[pattern];
    if (!pkg) {
      return;
    }
 
    const byName = this.patternsByPackage[pkg.name];
    if (!byName) {
      return;
    }
 
    byName.splice(byName.indexOf(pattern), 1);
    delete this.patterns[pattern];
  }
 
  /**
   * TODO description
   */
 
  getResolvedPattern(pattern) {
    return this.patterns[pattern];
  }
 
  /**
   * TODO description
   */
 
  getStrictResolvedPattern(pattern) {
    const manifest = this.getResolvedPattern(pattern);
    invariant(manifest, 'expected manifest');
    return manifest;
  }
 
  /**
   * TODO description
   */
 
  getExactVersionMatch(name, version) {
    const patterns = this.patternsByPackage[name];
    if (!patterns) {
      return null;
    }
 
    for (const pattern of patterns) {
      const info = this.getStrictResolvedPattern(pattern);
      if (info.version === version) {
        return info;
      }
    }
 
    return null;
  }
 
  /**
   * Get the manifest of the highest known version that satisfies a package range
   */
 
  getHighestRangeVersionMatch(name, range) {
    const patterns = this.patternsByPackage[name];
    if (!patterns) {
      return null;
    }
 
    const versionNumbers = [];
    const resolvedPatterns = patterns.map(pattern => {
      const info = this.getStrictResolvedPattern(pattern);
      versionNumbers.push(info.version);
 
      return info;
    });
 
    const maxValidRange = semver.maxSatisfying(versionNumbers, range);
    if (!maxValidRange) {
      return null;
    }
 
    const indexOfmaxValidRange = versionNumbers.indexOf(maxValidRange);
    const maxValidRangeManifest = resolvedPatterns[indexOfmaxValidRange];
 
    return maxValidRangeManifest;
  }
 
  /**
   * TODO description
   */
 
  find(req) {
    var _this = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      const fetchKey = `${req.registry}:${req.pattern}`;
      if (_this.fetchingPatterns[fetchKey]) {
        return;
      } else {
        _this.fetchingPatterns[fetchKey] = true;
      }
 
      if (_this.activity) {
        _this.activity.tick(req.pattern);
      }
 
      if (!_this.lockfile.getLocked(req.pattern, true)) {
        _this.newPatterns.push(req.pattern);
      }
 
      const request = new (_packageRequest || _load_packageRequest()).default(req, _this);
      yield request.find();
    })();
  }
 
  /**
   * TODO description
   */
 
  init(deps, isFlat) {
    var _this2 = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      _this2.flat = isFlat;
 
      //
      const activity = _this2.activity = _this2.reporter.activity();
 
      //
      _this2.seedPatterns = deps.map(function (dep) {
        return dep.pattern;
      });
 
      //
      yield (_promise || _load_promise()).default.all(deps.map(function (req) {
        return _this2.find(req);
      }));
 
      activity.end();
      _this2.activity = null;
    })();
  }
}
exports.default = PackageResolver;
 

1
2
 
 
'use strict';
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
 
 
1
 
 
1
1
 
1
 
 
 
 
 
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
1
 
 
 
1
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Parser = undefined;
exports.tokenise = tokenise;
 
exports.default = function (str) {
  let fileLoc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'lockfile';
 
  str = stripBOM(str);
  const parser = new Parser(str, fileLoc);
  parser.next();
  return parser.parse();
};
 
var _constants;
 
function _load_constants() {
  return _constants = require('../constants.js');
}
 
var _errors;
 
function _load_errors() {
  return _errors = require('../errors.js');
}
 
var _map;
 
function _load_map() {
  return _map = _interopRequireDefault(require('../util/map.js'));
}
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
const invariant = require('invariant');
/* eslint quotes: 0 */
 
const stripBOM = require('strip-bom');
 
const VERSION_REGEX = /^yarn lockfile v(\d+)$/;
 
const TOKEN_TYPES = {
  boolean: 'BOOLEAN',
  string: 'STRING',
  identifier: 'IDENTIFIER',
  eof: 'EOF',
  colon: 'COLON',
  newline: 'NEWLINE',
  comment: 'COMMENT',
  indent: 'INDENT',
  invalid: 'INVALID',
  number: 'NUMBER',
  comma: 'COMMA'
};
 
const VALID_PROP_VALUE_TOKENS = [TOKEN_TYPES.boolean, TOKEN_TYPES.string, TOKEN_TYPES.number];
 
function isValidPropValueToken(token) {
  return VALID_PROP_VALUE_TOKENS.indexOf(token.type) >= 0;
}
 
function* tokenise(input) {
  let lastNewline = false;
  let line = 1;
  let col = 0;
 
  function buildToken(type, value) {
    return { line: line, col: col, type: type, value: value };
  }
 
  while (input.length) {
    let chop = 0;
 
    if (input[0] === '\n') {
      chop++;
      line++;
      col = 0;
      yield buildToken(TOKEN_TYPES.newline);
    } else if (input[0] === '#') {
      chop++;
 
      let val = '';
      while (input[chop] !== '\n') {
        val += input[chop];
        chop++;
      }
      yield buildToken(TOKEN_TYPES.comment, val);
    } else if (input[0] === ' ') {
      if (lastNewline) {
        let indent = '';
        for (let i = 0; input[i] === ' '; i++) {
          indent += input[i];
        }
 
        if (indent.length % 2) {
          throw new TypeError('Invalid number of spaces');
        } else {
          chop = indent.length;
          yield buildToken(TOKEN_TYPES.indent, indent.length / 2);
        }
      } else {
        chop++;
      }
    } else if (input[0] === '"') {
      let val = '';
 
      for (let i = 0;; i++) {
        const currentChar = input[i];
        val += currentChar;
 
        if (i > 0 && currentChar === '"') {
          const isEscaped = input[i - 1] === "\\" && input[i - 2] !== "\\";
          if (!isEscaped) {
            break;
          }
        }
      }
 
      chop = val.length;
 
      try {
        yield buildToken(TOKEN_TYPES.string, JSON.parse(val));
      } catch (err) {
        if (err instanceof SyntaxError) {
          yield buildToken(TOKEN_TYPES.invalid);
        } else {
          throw err;
        }
      }
    } else if (/^[0-9]/.test(input)) {
      let val = '';
      for (let i = 0; /^[0-9]$/.test(input[i]); i++) {
        val += input[i];
      }
      chop = val.length;
 
      yield buildToken(TOKEN_TYPES.number, +val);
    } else if (/^true/.test(input)) {
      yield buildToken(TOKEN_TYPES.boolean, true);
      chop = 4;
    } else if (/^false/.test(input)) {
      yield buildToken(TOKEN_TYPES.boolean, false);
      chop = 5;
    } else if (input[0] === ':') {
      yield buildToken(TOKEN_TYPES.colon);
      chop++;
    } else if (input[0] === ',') {
      yield buildToken(TOKEN_TYPES.comma);
      chop++;
    } else if (/^[a-zA-Z]/g.test(input)) {
      let name = "";
      for (let i = 0; i < input.length; i++) {
        const char = input[i];
        if (char === ':' || char === ' ' || char === '\n' || char === ',') {
          break;
        } else {
          name += char;
        }
      }
      chop = name.length;
 
      yield buildToken(TOKEN_TYPES.string, name);
    } else {
      yield buildToken(TOKEN_TYPES.invalid);
    }
 
    if (!chop) {
      // will trigger infinite recursion
      yield buildToken(TOKEN_TYPES.invalid);
    }
 
    col += chop;
    lastNewline = input[0] === '\n';
    input = input.slice(chop);
  }
 
  yield buildToken(TOKEN_TYPES.eof);
}
 
class Parser {
  constructor(input) {
    let fileLoc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'lockfile';
 
    this.comments = [];
    this.tokens = tokenise(input);
    this.fileLoc = fileLoc;
  }
 
  onComment(token) {
    const value = token.value;
    invariant(typeof value === 'string', 'expected token value to be a string');
 
    const comment = value.trim();
 
    const versionMatch = comment.match(VERSION_REGEX);
    if (versionMatch) {
      const version = +versionMatch[1];
      if (version > (_constants || _load_constants()).LOCKFILE_VERSION) {
        throw new (_errors || _load_errors()).MessageError(`Can't install from a lockfile of version ${version} as you're on an old yarn version that only supports ` + `versions up to ${(_constants || _load_constants()).LOCKFILE_VERSION}. Run \`$ yarn self-update\` to upgrade to the latest version.`);
      }
    }
 
    this.comments.push(comment);
  }
 
  next() {
    const item = this.tokens.next();
    invariant(item, 'expected a token');
 
    const done = item.done,
          value = item.value;
 
    if (done || !value) {
      throw new Error('No more tokens');
    } else if (value.type === TOKEN_TYPES.comment) {
      this.onComment(value);
      return this.next();
    } else {
      return this.token = value;
    }
  }
 
  unexpected() {
    let msg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Unexpected token';
 
    throw new SyntaxError(`${msg} ${this.token.line}:${this.token.col} in ${this.fileLoc}`);
  }
 
  expect(tokType) {
    if (this.token.type === tokType) {
      this.next();
    } else {
      this.unexpected();
    }
  }
 
  eat(tokType) {
    if (this.token.type === tokType) {
      this.next();
      return true;
    } else {
      return false;
    }
  }
 
  parse() {
    let indent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
 
    const obj = (0, (_map || _load_map()).default)();
 
    while (true) {
      const propToken = this.token;
 
      if (propToken.type === TOKEN_TYPES.newline) {
        const nextToken = this.next();
        if (!indent) {
          // if we have 0 indentation then the next token doesn't matter
          continue;
        }
 
        if (nextToken.type !== TOKEN_TYPES.indent) {
          // if we have no indentation after a newline then we've gone down a level
          break;
        }
 
        if (nextToken.value === indent) {
          // all is good, the indent is on our level
          this.next();
        } else {
          // the indentation is less than our level
          break;
        }
      } else if (propToken.type === TOKEN_TYPES.indent) {
        if (propToken.value === indent) {
          this.next();
        } else {
          break;
        }
      } else if (propToken.type === TOKEN_TYPES.eof) {
        break;
      } else if (propToken.type === TOKEN_TYPES.string) {
        // property key
        const key = propToken.value;
        invariant(key, 'Expected a key');
 
        const keys = [key];
        this.next();
 
        // support multiple keys
        while (this.token.type === TOKEN_TYPES.comma) {
          this.next(); // skip comma
 
          const keyToken = this.token;
          if (keyToken.type !== TOKEN_TYPES.string) {
            this.unexpected('Expected string');
          }
 
          const key = keyToken.value;
          invariant(key, 'Expected a key');
          keys.push(key);
          this.next();
        }
 
        const valToken = this.token;
 
        if (valToken.type === TOKEN_TYPES.colon) {
          // object
          this.next();
 
          // parse object
          const val = this.parse(indent + 1);
 
          for (const key of keys) {
            obj[key] = val;
          }
 
          if (indent && this.token.type !== TOKEN_TYPES.indent) {
            break;
          }
        } else if (isValidPropValueToken(valToken)) {
          // plain value
          for (const key of keys) {
            obj[key] = valToken.value;
          }
 
          this.next();
        } else {
          this.unexpected('Invalid value type');
        }
      } else {
        this.unexpected('Unknown token');
      }
    }
 
    return obj;
  }
}
 
exports.Parser = Parser;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _keys;
 
function _load_keys() {
  return _keys = _interopRequireDefault(require('babel-runtime/core-js/object/keys'));
}
 
var _stringify2;
 
function _load_stringify() {
  return _stringify2 = _interopRequireDefault(require('babel-runtime/core-js/json/stringify'));
}
 
exports.default = stringify;
 
var _misc;
 
function _load_misc() {
  return _misc = require('../util/misc.js');
}
 
var _constants;
 
function _load_constants() {
  return _constants = require('../constants.js');
}
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
function shouldWrapKey(str) {
  return str.indexOf('true') === 0 || str.indexOf('false') === 0 || /[:\s\n\\",\[\]]/g.test(str) || /^[0-9]/g.test(str) || !/^[a-zA-Z]/g.test(str);
}
 
function maybeWrap(str) {
  if (typeof str === 'boolean' || typeof str === 'number' || shouldWrapKey(str)) {
    return (0, (_stringify2 || _load_stringify()).default)(str);
  } else {
    return str;
  }
}
 
const priorities = {
  name: 1,
  version: 2,
  uid: 3,
  resolved: 4,
  registry: 5,
  dependencies: 6
};
 
function priorityThenAlphaSort(a, b) {
  if (priorities[a] || priorities[b]) {
    return (priorities[a] || 100) > (priorities[b] || 100) ? 1 : -1;
  } else {
    return (0, (_misc || _load_misc()).sortAlpha)(a, b);
  }
}
 
function _stringify(obj, options) {
  if (typeof obj !== 'object') {
    throw new TypeError();
  }
 
  const indent = options.indent;
  const lines = [];
 
  // Sorting order needs to be consistent between runs, we run native sort by name because there are no
  // problems with it being unstable because there are no to keys the same
  // However priorities can be duplicated and native sort can shuffle things from run to run
  const keys = (0, (_keys || _load_keys()).default)(obj).sort(priorityThenAlphaSort);
 
  let addedKeys = [];
 
  for (let i = 0; i < keys.length; i++) {
    const key = keys[i];
    const val = obj[key];
    if (val == null || addedKeys.indexOf(key) >= 0) {
      continue;
    }
 
    //
    const valKeys = [key];
 
    // get all keys that have the same value equality, we only want this for objects
    if (typeof val === 'object') {
      for (let j = i + 1; j < keys.length; j++) {
        const key = keys[j];
        if (val === obj[key]) {
          valKeys.push(key);
        }
      }
    }
 
    //
    const keyLine = valKeys.sort((_misc || _load_misc()).sortAlpha).map(maybeWrap).join(', ');
 
    if (typeof val === 'string' || typeof val === 'boolean' || typeof val === 'number') {
      lines.push(`${keyLine} ${maybeWrap(val)}`);
    } else if (typeof val === 'object') {
      lines.push(`${keyLine}:\n${_stringify(val, { indent: indent + '  ' })}` + (options.topLevel ? '\n' : ''));
    } else {
      throw new TypeError();
    }
 
    addedKeys = addedKeys.concat(valKeys);
  }
 
  return indent + lines.join(`\n${indent}`);
}
 
function stringify(obj, noHeader) {
  const val = _stringify(obj, {
    indent: '',
    topLevel: true
  });
  if (noHeader) {
    return val;
  }
 
  return ['# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.', `# yarn lockfile v${(_constants || _load_constants()).LOCKFILE_VERSION}`, '\n', val].join('\n');
}
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
 
 
1
 
 
1
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
1
 
 
1
 
 
4
 
 
 
1
 
1
1
 
 
1
 
 
2
 
 
1
1
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
6
 
1
1
 
1
 
 
 
1
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.stringify = exports.parse = undefined;
 
var _map;
 
function _load_map() {
  return _map = _interopRequireDefault(require('babel-runtime/core-js/map'));
}
 
var _asyncToGenerator2;
 
function _load_asyncToGenerator() {
  return _asyncToGenerator2 = _interopRequireDefault(require('babel-runtime/helpers/asyncToGenerator'));
}
 
var _keys;
 
function _load_keys() {
  return _keys = _interopRequireDefault(require('babel-runtime/core-js/object/keys'));
}
 
var _parse;
 
function _load_parse() {
  return _parse = require('./parse');
}
 
Object.defineProperty(exports, 'parse', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_parse || _load_parse()).default;
  }
});
 
var _stringify;
 
function _load_stringify() {
  return _stringify = require('./stringify');
}
 
Object.defineProperty(exports, 'stringify', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_stringify || _load_stringify()).default;
  }
});
exports.implodeEntry = implodeEntry;
exports.explodeEntry = explodeEntry;
 
var _misc;
 
function _load_misc() {
  return _misc = require('../util/misc.js');
}
 
var _packageRequest;
 
function _load_packageRequest() {
  return _packageRequest = _interopRequireDefault(require('../package-request.js'));
}
 
var _parse2;
 
function _load_parse2() {
  return _parse2 = _interopRequireDefault(require('./parse.js'));
}
 
var _constants;
 
function _load_constants() {
  return _constants = _interopRequireWildcard(require('../constants.js'));
}
 
var _fs;
 
function _load_fs() {
  return _fs = _interopRequireWildcard(require('../util/fs.js'));
}
 
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
const invariant = require('invariant');
const path = require('path');
 
function getName(pattern) {
  return (_packageRequest || _load_packageRequest()).default.normalizePattern(pattern).name;
}
 
function blankObjectUndefined(obj) {
  return obj && (0, (_keys || _load_keys()).default)(obj).length ? obj : undefined;
}
 
function implodeEntry(pattern, obj) {
  const inferredName = getName(pattern);
  return {
    name: inferredName === obj.name ? undefined : obj.name,
    version: obj.version,
    uid: obj.uid === obj.version ? undefined : obj.uid,
    resolved: obj.resolved,
    registry: obj.registry === 'npm' ? undefined : obj.registry,
    dependencies: blankObjectUndefined(obj.dependencies),
    optionalDependencies: blankObjectUndefined(obj.optionalDependencies),
    permissions: blankObjectUndefined(obj.permissions)
  };
}
 
function explodeEntry(pattern, obj) {
  obj.optionalDependencies = obj.optionalDependencies || {};
  obj.dependencies = obj.dependencies || {};
  obj.uid = obj.uid || obj.version;
  obj.permissions = obj.permissions || {};
  obj.registry = obj.registry || 'npm';
  obj.name = obj.name || getName(pattern);
  return obj;
}
 
class Lockfile {
  constructor(cache, source) {
    this.source = source || '';
    this.cache = cache;
  }
 
  // source string if the `cache` was parsed
 
 
  static fromDirectory(dir, reporter) {
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      // read the manifest in this directory
      const lockfileLoc = path.join(dir, (_constants || _load_constants()).LOCKFILE_FILENAME);
      let lockfile;
      let rawLockfile = '';
 
      if (yield (_fs || _load_fs()).exists(lockfileLoc)) {
        rawLockfile = yield (_fs || _load_fs()).readFile(lockfileLoc);
        lockfile = (0, (_parse2 || _load_parse2()).default)(rawLockfile, lockfileLoc);
      } else {
        if (reporter) {
          reporter.info(reporter.lang('noLockfileFound'));
        }
      }
 
      return new Lockfile(lockfile, rawLockfile);
    })();
  }
 
  getLocked(pattern) {
    const cache = this.cache;
    if (!cache) {
      return undefined;
    }
 
    const shrunk = pattern in cache && cache[pattern];
 
    if (typeof shrunk === 'string') {
      return this.getLocked(shrunk);
    } else if (shrunk) {
      explodeEntry(pattern, shrunk);
      return shrunk;
    }
 
    return undefined;
  }
 
  getLockfile(patterns) {
    const lockfile = {};
    const seen = new (_map || _load_map()).default();
 
    // order by name so that lockfile manifest is assigned to the first dependency with this manifest
    // the others that have the same remote.resolved will just refer to the first
    // ordering allows for consistency in lockfile when it is serialized
    const sortedPatternsKeys = (0, (_keys || _load_keys()).default)(patterns).sort((_misc || _load_misc()).sortAlpha);
 
    for (const pattern of sortedPatternsKeys) {
      const pkg = patterns[pattern];
      const remote = pkg._remote,
            ref = pkg._reference;
 
      invariant(ref, 'Package is missing a reference');
      invariant(remote, 'Package is missing a remote');
 
      const seenPattern = remote.resolved && seen.get(remote.resolved);
      if (seenPattern) {
        // no point in duplicating it
        lockfile[pattern] = seenPattern;
 
        // if we're relying on our name being inferred and two of the patterns have
        // different inferred names then we need to set it
        if (!seenPattern.name && getName(pattern) !== pkg.name) {
          seenPattern.name = pkg.name;
        }
        continue;
      }
 
      const obj = implodeEntry(pattern, {
        name: pkg.name,
        version: pkg.version,
        uid: pkg._uid,
        resolved: remote.resolved,
        registry: remote.registry,
        dependencies: pkg.dependencies,
        peerDependencies: pkg.peerDependencies,
        optionalDependencies: pkg.optionalDependencies,
        permissions: ref.permissions
      });
      lockfile[pattern] = obj;
 
      if (remote.resolved) {
        seen.set(remote.resolved, obj);
      }
    }
 
    return lockfile;
  }
}
exports.default = Lockfile;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
 
 
 
1
 
1
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _asyncToGenerator2;
 
function _load_asyncToGenerator() {
  return _asyncToGenerator2 = _interopRequireDefault(require('babel-runtime/helpers/asyncToGenerator'));
}
 
var _extends2;
 
function _load_extends() {
  return _extends2 = _interopRequireDefault(require('babel-runtime/helpers/extends'));
}
 
var _promise;
 
function _load_promise() {
  return _promise = _interopRequireDefault(require('babel-runtime/core-js/promise'));
}
 
var _keys;
 
function _load_keys() {
  return _keys = _interopRequireDefault(require('babel-runtime/core-js/object/keys'));
}
 
var _misc;
 
function _load_misc() {
  return _misc = require('../util/misc.js');
}
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
const objectPath = require('object-path');
const path = require('path');
 
class BaseRegistry {
  constructor(cwd, registries, requestManager) {
    this.requestManager = requestManager;
    this.registries = registries;
    this.config = {};
    this.folder = '';
    this.token = '';
    this.loc = '';
    this.cwd = cwd;
  }
 
  // the filename to use for package metadata
 
 
  //
 
 
  //
 
 
  //
 
 
  //
 
 
  //
 
 
  // absolute folder name to insert modules
 
 
  // relative folder name to put these modules
 
 
  setToken(token) {
    this.token = token;
  }
 
  getOption(key) {
    return this.config[key];
  }
 
  getAvailableRegistries() {
    const config = this.config;
    return (0, (_keys || _load_keys()).default)(config).reduce((registries, option) => {
      if (option === 'registry' || option.split(':')[1] === 'registry') {
        registries.push(config[option]);
      }
      return registries;
    }, []);
  }
 
  loadConfig() {
    return (_promise || _load_promise()).default.resolve();
  }
 
  checkOutdated(config, name, range) {
    return (_promise || _load_promise()).default.reject(new Error('unimplemented'));
  }
 
  saveHomeConfig(config) {
    return (_promise || _load_promise()).default.reject(new Error('unimplemented'));
  }
 
  request(pathname) {
    let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
    return this.requestManager.request((0, (_extends2 || _load_extends()).default)({
      url: pathname
    }, opts));
  }
 
  init() {
    var _this = this;
 
    return (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)(function* () {
      _this.mergeEnv('yarn_');
      yield _this.loadConfig();
      _this.loc = path.join(_this.cwd, _this.folder);
    })();
  }
 
  static normalizeConfig(config) {
    for (const key in config) {
      config[key] = BaseRegistry.normalizeConfigOption(config[key]);
    }
    return config;
  }
 
  static normalizeConfigOption(val) {
    if (val === 'true') {
      return true;
    } else if (val === 'false') {
      return false;
    } else {
      return val;
    }
  }
 
  mergeEnv(prefix) {
    // try environment variables
    for (let key in process.env) {
      key = key.toLowerCase();
 
      // only accept keys prefixed with the prefix
      if (key.indexOf(prefix) < 0) {
        continue;
      }
 
      const val = BaseRegistry.normalizeConfigOption(process.env[key]);
 
      // remove config prefix
      key = (0, (_misc || _load_misc()).removePrefix)(key, prefix);
 
      // replace dunders with dots
      key = key.replace(/__/g, '.');
 
      // replace underscores with dashes
      key = key.replace(/_/g, '-');
 
      // set it via a path
      objectPath.set(this.config, key, val);
    }
  }
}
exports.default = BaseRegistry;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
 
1
 
 
1
 
1
 
1
 
 
 
1
 
1
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = isRequestToRegistry;
 
var _url;
 
function _load_url() {
  return _url = _interopRequireDefault(require('url'));
}
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
function isRequestToRegistry(requestUrl, registry) {
  const requestParsed = (_url || _load_url()).default.parse(requestUrl);
  const registryParsed = (_url || _load_url()).default.parse(registry);
  const requestPort = getPortOrDefaultPort(requestParsed.port, requestParsed.protocol);
  const registryPort = getPortOrDefaultPort(registryParsed.port, registryParsed.protocol);
  const requestPath = requestParsed.path || '';
  const registryPath = registryParsed.path || '';
 
  return requestParsed.protocol === registryParsed.protocol && requestParsed.hostname === registryParsed.hostname && requestPort === registryPort && requestPath.startsWith(registryPath);
}
 
function getPortOrDefaultPort(port, protocol) {
  const defaultPort = !port;
  if (defaultPort && protocol === 'https:') {
    return '443';
  }
  if (defaultPort && protocol === 'http:') {
    return '80';
  }
  return port;
}